# Funktionen zeichnen



## Cyz44 (18. Jun 2012)

Am Freitag muss ich meinen fertigen (grafikfähigen)- Taschenrechner vorzeigen, das Problem: er kann noch nichts zeichnen!! Die Grundrechenarten hat er drauf, ein Koordinatensystem mit entsprechender Skalierung auch. Aber bei den Funktionen komme ich einfach nicht weiter. Kann mir einer einen Denkanstoß in diese Richtung geben?


```
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

/**
  *
  * description
  *
  * @version 1.0 from 09.04.2012
  * @Cyrus Zeller
  */

public class q extends JFrame
{
  // Anfang Attribute
  private JButton Null = new JButton();
  private JButton eins = new JButton();
  private JButton zwei = new JButton();
  private JButton drei = new JButton();
  private JButton vier = new JButton();
  private JButton fuenf = new JButton();
  private JButton sechs = new JButton();
  private JButton sieben = new JButton();
  private JButton acht = new JButton();
  private JButton neun = new JButton();
  private JButton punkt = new JButton();
  private JButton enter = new JButton();
  private JButton plus = new JButton();
  private JButton minus = new JButton();
  private JButton mal = new JButton();
  private JButton geteilt = new JButton();
  private JButton variable = new JButton();
  private JButton pi = new JButton();
  private JButton hoch2 = new JButton();
  private JButton wurzel = new JButton();
  private JButton clear = new JButton();
  private JButton graph = new JButton();
  private JButton windowset = new JButton();
  private JTextArea display1 = new JTextArea();
  private JButton funktionen = new JButton();
  private JScrollPane display1ScrollPane = new JScrollPane(display1);
  int a, b, c, d, e, f;

  boolean start = true;
  private String lastCommand;
  private double result;

  JFrame fenster = null;
  JPanel hauptFlaeche = null;
  ZeichenFlaeche zeichenFlaeche = null;

  private JTextField Xmin = new JTextField("Xmin=", 50);
  private JTextField Xmax = new JTextField("Xmax=", 50);
  private JTextField Xscl = new JTextField("Xscl=", 50);
  private JTextField Ymin = new JTextField("Ymin=", 50);
  private JTextField Ymax = new JTextField("Ymax=", 50);
  private JTextField Yscl = new JTextField("Yscl=", 50);
  private JTextField funktion1 = new JTextField("Y1 =", 50);
  private JTextField funktion2 = new JTextField("Y2 =", 50);
  private JButton sinus = new JButton();
  private JButton cosinus = new JButton();
  private JButton tangens = new JButton();
  // Ende Attribute

  public q (String title)
  {
    super (title);
    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    int frameWidth = 500; 
    int frameHeight = 600;
    setSize(frameWidth, frameHeight);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    int x = (d.width - getSize().width) / 2;
    int y = (d.height - getSize().height) / 2;
    setLocation(x, y);
    Container cp = getContentPane();
    cp.setLayout(null);
    cp.setBackground(new Color(0xB8CFE5));
    
    zeichneFenster();

    achsenbeschriftung();
    setRows();

    
    
    // Anfang Komponenten
    Null.setBounds(104, 328, 60, 40);
    Null.setText("0");
    Null.setMargin(new Insets(2, 2, 2, 2));
    Null.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        Null_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "0";
        display1.setText(text);
      }
    });
    cp.add(Null);
    
    eins.setBounds(104, 280, 60, 40);
    eins.setText("1");
    eins.setMargin(new Insets(1, 2, 2, 2));
    eins.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        eins_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "1";
        display1.setText(text);
      }
    });
    cp.add(eins);
    
    zwei.setBounds(176, 280, 60, 40);
    zwei.setText("2");
    zwei.setMargin(new Insets(2, 2, 2, 2));
    zwei.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        zwei_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "2";
        display1.setText(text);
      }
    });
    cp.add(zwei);
    
    drei.setBounds(248, 280, 60, 40);
    drei.setText("3");
    drei.setMargin(new Insets(2, 2, 2, 2));
    drei.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent evt)
      { 
        drei_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "3";
        display1.setText(text);
      }
    });
    cp.add(drei);
    
    vier.setBounds(104, 232, 60, 40);
    vier.setText("4");
    vier.setMargin(new Insets(2, 2, 2, 2));
    vier.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        vier_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "4";
        display1.setText(text);
      }
    });
    cp.add(vier);
    
    fuenf.setBounds(176, 232, 60, 40);
    fuenf.setText("5");
    fuenf.setMargin(new Insets(2, 2, 2, 2));
    fuenf.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      {
        fuenf_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "5";
        display1.setText(text);
      }
    });
    cp.add(fuenf);
    
    sechs.setBounds(248, 232, 60, 40);
    sechs.setText("6");
    sechs.setMargin(new Insets(2, 2, 2, 2));
    sechs.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        sechs_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "6";
        display1.setText(text);
      }
    });
    cp.add(sechs);
    
    sieben.setBounds(104, 184, 60, 40);
    sieben.setText("7");
    sieben.setMargin(new Insets(2, 2, 2, 2));
    sieben.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        sieben_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "7";
        display1.setText(text);
      }
    });
    cp.add(sieben);
    
    acht.setBounds(176, 184, 60, 40);
    acht.setText("8");
    acht.setMargin(new Insets(2, 2, 2, 2));
    acht.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        acht_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "8";
        display1.setText(text);
      }
    });
    cp.add(acht);
    
    neun.setBounds(248, 184, 60, 40);
    neun.setText("9");
    neun.setMargin(new Insets(2, 2, 2, 2));
    neun.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        neun_ActionPerformed(evt);
        
        String text = display1.getText();
        text += "9";
        display1.setText(text);
      }
    });
    cp.add(neun);
    
    punkt.setBounds(176, 328, 60, 40);
    punkt.setText(".");
    punkt.setMargin(new Insets(2, 2, 2, 2));
    punkt.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        punkt_ActionPerformed(evt);
        String text = display1.getText();
        text += ".";
        display1.setText(text);
      }
    });
    cp.add(punkt);
    
    enter.setBounds(248, 328, 60, 40);
    enter.setText("Enter");
    enter.setMargin(new Insets(2, 2, 2, 2));
    enter.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        enter_ActionPerformed(evt);
        String rechnung = display1.getText();
        ScriptEngineManager mgr = new ScriptEngineManager();
        ScriptEngine engine = mgr.getEngineByName("js");
        try
        {
               String text =  (engine.eval(rechnung)).toString();
               display1.setText(text);
        } catch(Exception e){}
      }
    });
    cp.add(enter);
    
    plus.setBounds(320, 184, 60, 40);
    plus.setText("+");
    plus.setMargin(new Insets(2, 2, 2, 2));
    plus.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        plus_ActionPerformed(evt);
        String text = display1.getText();
        text += "+";
        display1.setText(text);
      }
    });
    cp.add(plus);
    
    minus.setBounds(320, 232, 60, 40);
    minus.setText("-");
    minus.setMargin(new Insets(2, 2, 2, 2));
    minus.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        minus_ActionPerformed(evt);
        String text = display1.getText();
        text += "-";
        display1.setText(text);
      }
    });
    cp.add(minus);
    
    mal.setBounds(320, 280, 60, 40);
    mal.setText("*");
    mal.setMargin(new Insets(2, 2, 2, 2));
    mal.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        mal_ActionPerformed(evt);
        String text = display1.getText();
        text += "*";
        display1.setText(text);
      }
    });
    cp.add(mal);
    
    geteilt.setBounds(320, 328, 60, 40);
    geteilt.setText("/");
    geteilt.setMargin(new Insets(2, 2, 2, 2));
    geteilt.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        geteilt_ActionPerformed(evt);
        String text = display1.getText();
        text += "/";
        display1.setText(text);
      }
    });
    cp.add(geteilt);
    
    variable.setBounds(104, 376, 60, 40);
    variable.setText("x");
    variable.setMargin(new Insets(2, 2, 2, 2));
    variable.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        variable_ActionPerformed(evt);
        String text = display1.getText();
        text += "x";
        display1.setText(text);
      }
    });
    cp.add(variable);
    
    pi.setBounds(176, 376, 60, 40);
    pi.setText("\u03C0");
    pi.setMargin(new Insets(2, 2, 2, 2));
    pi.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        pi_ActionPerformed(evt);
        String text = display1.getText();
//        text += "\u03C0";
        double pi = Math.PI;
        String str = String.valueOf(pi);
        text += str;
        display1.setText(text);
      }
    });
    cp.add(pi);
    
    hoch2.setBounds(248, 376, 60, 40);
    hoch2.setText("x²");
    hoch2.setMargin(new Insets(2, 2, 2, 2));
    hoch2.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        hoch2_ActionPerformed(evt);
        String text = display1.getText();
        text += "";
        display1.setText(text);
      }
    });
    cp.add(hoch2);
    
    wurzel.setBounds(320, 376, 60, 40);
    wurzel.setText("\u221A");
    wurzel.setMargin(new Insets(2, 2, 2, 2));
    wurzel.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        wurzel_ActionPerformed(evt);
        String text = display1.getText();
        text += "0";
        display1.setText(text);
      }
    });
    cp.add(wurzel);
    
    clear.setBounds(104, 424, 60, 40);
    clear.setText("C");
    clear.setMargin(new Insets(2, 2, 2, 2));
    clear.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        clear_ActionPerformed(evt);
        display1.setText("");
        zeichenFlaeche.loeschen(5);
        zeichenFlaeche.loescheZeichenflaeche();
      }
    });
    cp.add(clear);
    
    graph.setBounds(176, 424, 60, 40);
    graph.setText("Graph");
    graph.setMargin(new Insets(2, 2, 2, 2));
    graph.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        graph_ActionPerformed(evt);

//                fenster.setVisible(true);
      }
    });
    cp.add(graph);
    
    windowset.setBounds(248, 424, 60, 40);
    windowset.setText("Window");
    windowset.setMargin(new Insets(2, 2, 2, 2));
    windowset.addActionListener(new ActionListener()
    { 
      public void actionPerformed(ActionEvent evt)
      { 
        windowset_ActionPerformed(evt);
        fenster.setVisible(false);
      }
    });
    cp.add(windowset);
    
    funktionen.setBounds(320, 424, 60, 40);
    funktionen.setText("Y =");
    funktionen.setMargin(new Insets(2, 2, 2, 2));
    funktionen.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent evt)
      {
        funktionen_ActionPerformed(evt);
      }
    });
    cp.add(funktionen);
    
    sinus.setBounds(104, 472, 60, 40);
    sinus.setText("Sin");
    sinus.setMargin(new Insets(2, 2, 2, 2));
    sinus.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent evt)
      {
        sinus_ActionPerformed(evt);
        String text = display1.getText();
        text += "sin(";
        display1.setText(text);
      }
    });
    cp.add(sinus);
    
    cosinus.setBounds(176, 472, 60, 40);
    cosinus.setText("Cos");
    cosinus.setMargin(new Insets(2, 2, 2, 2));
    cosinus.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent evt)
      {
        cosinus_ActionPerformed(evt);
        String text = display1.getText();
        text += "cos(";
        display1.setText(text);
      }
    });
    cp.add(cosinus);
    
    tangens.setBounds(248, 472, 60, 40);
    tangens.setText("Tan");
    tangens.setMargin(new Insets(2, 2, 2, 2));
    tangens.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent evt)
      {
        tangens_ActionPerformed(evt);
        String text = display1.getText();
        text += "tan(";
        display1.setText(text);
      }
    });
    cp.add(tangens);
    
    display1ScrollPane.setBounds(88, 32, 280, 120);
    cp.add(display1ScrollPane);

    Xmin.setBounds(24, 32, 65, 20);
    cp.add(Xmin);
    Xmax.setBounds(24, 52, 65, 20);
    cp.add(Xmax);
    Xscl.setBounds(24, 72, 65, 20);
    cp.add(Xscl);
    Ymin.setBounds(24, 92, 65, 20);
    cp.add(Ymin);
    Ymax.setBounds(24, 112, 65, 20);
    cp.add(Ymax);
    Yscl.setBounds(24, 132, 65, 20);
    cp.add(Yscl);
    funktion1.setBounds(376, 32, 65, 20);
    cp.add(funktion1);
    funktion2.setBounds(376, 48, 65, 20);
    cp.add(funktion2);


    // Ende Komponenten
    setResizable(false);
    setVisible(true);
  }

  // Anfang Methoden
  

  public void zeichneFenster()                                     // erstellen einer Zeichenfläche in einem neuen Fenster
  {
    fenster = new JFrame();
    fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    fenster.setTitle("Koordinatensystem");
    hauptFlaeche = new JPanel(new BorderLayout());
    zeichenFlaeche = new ZeichenFlaeche();
    hauptFlaeche.add(zeichenFlaeche, BorderLayout.CENTER);
    fenster.getContentPane().add(hauptFlaeche);
    fenster.pack();
    fenster.setResizable(false);
    fenster.setVisible(false);
  }
  


  public void achsenbeschriftung()
  {

  }
  
  public void setRows()
  {
    //String[] zeile = display1.getText();

  }



  public void Null_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void eins_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void zwei_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void drei_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void vier_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void fuenf_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void sechs_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void sieben_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void acht_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void neun_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void punkt_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void enter_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void plus_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void minus_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void mal_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void geteilt_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void variable_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void pi_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void hoch2_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void wurzel_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void clear_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public int yAchsePosition()
  {
    int breite = 700;
    String str1 = Xmin.getText();
    String str2 = Xmax.getText();
    String[] aa = str1.split("=");
    String[] bb = str2.split("=");
    int a = Integer.parseInt(aa[1]);
    int b = Integer.parseInt(bb[1]);
    
    int xmin = (breite/(-a+b)) * (-a);
    return xmin;
  }

  public int xAchsePosition()
  {
    int höhe = 700;
    String str3 = Ymin.getText();
    String str4 = Ymax.getText();
    String[] cc = str3.split("=");
    String[] dd = str4.split("=");
    int c = Integer.parseInt(cc[1]);
    int d = Integer.parseInt(dd[1]);
    
    int ymin = (höhe/(-c+d)) * (d);
    return ymin;
  }

  public int xSumme()                            // berechnet die Summe der beiden x-Eingaben
  {
    String str1 = Xmin.getText();
    String str2 = Xmax.getText();
    String[] aa = str1.split("=");
    String[] bb = str2.split("=");
    int a = Integer.parseInt(aa[1]);
    int b = Integer.parseInt(bb[1]);
    int x = (-a + b);
    return x;
  }

  public int ySumme()                           // berechnet die Summe der beiden y-Eingaben
  {
    String str1 = Ymin.getText();
    String str2 = Ymax.getText();
    String[] aa = str1.split("=");
    String[] bb = str2.split("=");
    int a = Integer.parseInt(aa[1]);
    int b = Integer.parseInt(bb[1]);
    int y = (-a + b);
    return y;
  }
  
  public int xScale()
  {
    String a = Xscl.getText();
    String[] c = a.split("=");
    int xscl = Integer.parseInt(c[1]);
    return xscl;
  }
  
  public int yScale()
  {
    String b = Yscl.getText();
    String[] d = b.split("=");
    int yscl = Integer.parseInt(d[1]);
    return yscl;
  }

  public void graph_ActionPerformed(ActionEvent evt)
  {
    int x = yAchsePosition();
    int y = xAchsePosition();
    int a = xSumme();
    int b = ySumme();
    int xx = xScale();
    int yy = yScale();
    
    zeichenFlaeche.macheZeichenFlaecheSichtbar(700, 700);
    zeichenFlaeche.setzeLinie(5, x, 0, x, 700);          // y-achse
    zeichenFlaeche.setzeLinie(5, 0, y, 700, y);          // x-achse

    int faktor1 = a/xx;
    int xscl = 700/faktor1;
    for (int z=0; z<faktor1; z++)
    {
      zeichenFlaeche.setzeLinie(5, x+xscl, y-10, x+xscl, y+10);   // Skalierungsstriche X-Achse

      zeichenFlaeche.setzeLinie(5, x-xscl, y-10, x-xscl, y+10);
      xscl = xscl+xscl;
    }

    int faktor2 = b/yy;
    int yscl = 700/faktor2;
    for (int w=0; w<faktor2; w++)
    {
      zeichenFlaeche.setzeLinie(5, x-10, y+yscl, x+10, y+yscl);   // Skalierungsstriche Y-Achse
      zeichenFlaeche.setzeLinie(5, x-10, y-yscl, x+10, y-yscl);
      yscl = yscl + yscl;
    }

  }

  public void windowset_ActionPerformed(ActionEvent evt)
  {

  }

  public void funktionen_ActionPerformed(ActionEvent evt)
  {

  }

  public void sinus_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void cosinus_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  public void tangens_ActionPerformed(ActionEvent evt) {
    // TODO hier Quelltext einfügen
  }

  // Ende Methoden

  public static void main(String[] args)
  {
    new q("q");
    
  }
}
```

Gezeichnet wird halt über die Klasse ZeichenFlaeche (kann ich auch noch posten falls nötig). Das wichtigste, das zeichnen von Funktionen, hab ich aber noch nicht eingebaut. Ich sitz schon seit Wochen dran. Deshalb wäre ich sehr dankbar (egal ob pseudo- oder java code) über JEDE! Hilfe oder vielleicht auch so etwas wie eine allgemeine Formel mit der man die einzelnen Funktionswerte berechnen kann. (Ich hoffe das klang jetzt einigermaßen verständlich )
lg


----------



## Marco13 (18. Jun 2012)

Mit http://www.java-forum.org/bilder-gui-damit-zusammenhaengt/49255-componenten-listener.html (und ein bißchen ... was auch immer) könnte man das auf die Hälfte oder weniger der Zeilen zusammenschnurren lassen. Ansonsten ist das, was du brauchst, wohl ein http://www.java-forum.org/codeschnipsel-u-projekte/122994-einfacher-funktionsplotter.html , aber WAS genau die Frage ist, hat sich mir nicht ganz erschlossen.


----------



## Cyz44 (19. Jun 2012)

Jaa die Frage war jetzt wirklich nicht so klar formuliert... :lol:
Danke für den Link, mal schauen ob ich den teil der die funktionen plottet daraus übernehmen kann.


----------



## Cyz44 (25. Jun 2012)

Hi, nachdem ich jetzt ein paar tage keine Zeit hatte weiterzumachen hab ich mich mal heute wieder drangesetzt. Hab aber ein kleines problem beim zeichnen von linearen funktionen.
Die Steigung funzt, aber wenn ich nur ein  eine einfache gerade ohne steigung zeichnen will klappt es nicht. Und auch die Verschiebung des y-schnittpunktes haut so nicht hin..



```
String X = "x";
    String A = funktion1.getText();
    String[] B = A.split("x");
    int xPunkt = 0;
    int yPunkt = 0;
    int steigung = Integer.parseInt(B[0]);
    int schnittstelle = Integer.parseInt(B[1]);
    int faktor3 = schnittstelle / b;
    schnittstelle = 700 * faktor3;
    

      for (int r=0; r<400; r++)
      {
        zeichenFlaeche.setzePunkt(5, x+xPunkt, (y-yPunkt*steigung)-schnittstelle);
        zeichenFlaeche.setzePunkt(5, x-xPunkt, (y+yPunkt*steigung)-schnittstelle);
          
        xPunkt++;
        yPunkt++;
      }
```


----------



## SlaterB (25. Jun 2012)

was ist denn A im Problemfall? was ist die steigung?
die Berechnung kannst du doch loggen, nicht gleich 400 oder 800 Werte auf einmal, sondern erst 2,3

was ist der Wert von x?
wie rechnest du y auf dem Papier aus? die steigung musst du doch wohl eher mit xPunkt multiplizieren?..
yPunkt brauchst du gar nicht, y hängt nur von x ab, evtl. von initialier y-Verschiebung,

da yPunkt eh immer gleich xPunkt ist, stört es im Moment wohl nicht..


----------



## Cyz44 (25. Jun 2012)

in A wird die funktion eingelesen und dann in zwei B[] arrays aufgesplittet links- und rechts vom x also bsp:

2x+3  2 in array1 und 3 in array2

x ist der wert, wo die y-achse auf dem panel liegt und y müsste so eig auch stimmen. Die steigung berechnet er ja auch aber die schnittstelle komischerweise nicht...


----------



## SlaterB (25. Jun 2012)

was ist 'die schnittstelle', was genau wird dort 'komischerweise' berechnet?

bitte viel mehr Fakten, Problembeschreibungen, mit System.out.println nachschauen was das Programm macht usw.

mit "was ist denn A im Problemfall?" meinte ich übrigens "wenn ich nur ein eine einfache gerade ohne steigung zeichnen will",
wofür 2x+3 wohl kaum ein Beispiel ist


----------



## Cyz44 (25. Jun 2012)

´schnittstelle´ ist die stelle an der die Gerade die y-Achse schneiden soll. Die x-Koordinate jedes Punktes ist ja klar oder? Der Position der y-achse wird bei jedem durchgang ein weiterer punkt (xpunkt) dazuaddiert, und zwar in positiver und negativer richtung.

Die y-koordinate ergibt sich daraus, wie weit ´unten´ die x-achse ist. Die steigung nimmt man dann * mit einem ypunkt und hat so schonmal die steigung was auch funzt.

P.S. okay hab mal schnittstelle ausgeben lassen, es hat iwie immer 0 berechnet 
werd das mal schnell ausbessern...


----------



## SlaterB (25. Jun 2012)

die Berechnung von y ist an jeder Stelle gleich, bei einer Geraden sollten die berechneten Punkte auch wirklich eine Gerade bilden,
da ist am Schnittpunkt mit der x-Achse wirklich nichts besonderes los, jeder Punkt sollte korrekt sein


----------



## Cyz44 (25. Jun 2012)

ok ich glaub es klappte nicht, weil faktor3 ein int-wert war obwohl das ergebniss eig immer zwischen 0 und 1 lag - deshalb wird es immer zu 0 abgerundet... Naja ich probiers mal jetzt mit ner anderen formel.

Was ich jetzt fragen wollte: Wie kann ich Parabeln und Ganzrationale Funktionen anzeigen lassen? Was müsste ich für eine formel aufstellen? (hatte ich auch am anfang des threads schon einmal gefragt).
Ich hoffe ihr versteht was ich meine, bin in mathe ohnehin nicht der beste und dass dann noch irgendwie in einem Javaprogramm zu implementieren...  Also ich wäre jedenfalls über jede Hilfe dankbar.


----------



## SlaterB (25. Jun 2012)

rechnen kann man alles wie auf dem Papier, notfalls anfangs mit vielen Variablen, ifs und unschönen Code,
du brauchst eine allgemeine Formel, nach der sich dann auch die Eingabe richtet:
a*x^b + c
wäre etwas mehr, für Funktionen wie sin() wirds komplizierter

wenn du dich allein dazu beschäftigen willst, kann es so groß werden wie
http://www.java-forum.org/allgemeines/12306-parser-fuer-mathematische-formeln.html


----------



## Cyz44 (25. Jun 2012)

Danke für den Link, sieht aber doch bissl sehr kompliziert aus... 
Als Beispiel: Wie soll es eine Universelle Formel geben (so hab ich es jetzt verstanden), wenn Geraden und GRFunktionen unterschiedliche Formeln haben?


----------



## SlaterB (25. Jun 2012)

ohne Beispiele von dir kann ich Unterschiede nicht erkennen,
wenn a 0 ist kann man eine Waagerechte immer noch gut schaffen, eine Senkrechte natürlich nicht ganz so gut,
da kommt "y = .. " selber ins Wanken

aber ich will und kann auch gar nicht deine generellen Programmprobleme lösen,
wie die GUI aussieht, was der Benutzer eingibt und damit ausdrücken will usw., das musst du java-unabhängig selber entscheiden


----------



## Cyz44 (27. Jun 2012)

Hey Ich bins nochmal zu später Stund. 
Ich bin jetzt bei den parabeln dran, vom prinzip her funktionierts auch. Für jeden einzelnen xPixel wird der zugehörige y-wert (hier yPunkt) berechnet. Allerdings kommen immer Komma werte raus und das geht nicht, weil die linie kann nur int-werte zeichnen. Weiß jemand wie ich dieses Problem umgehen kann?



```
/**
       *  Auswerten der Quadratischen Gleichung
       */

      String XX = "x²";
      String AA = unbekannte2.getText();
      if (AA.equals(XX))
      {

        String d = steigung2.getText();
        int steigung2 = Integer.parseInt(d);
        String e = verschiebungX.getText();
        int verschiebungX = Integer.parseInt(e);
        String f = verschiebungY.getText();
        int verschiebungY = Integer.parseInt(f);
        int xPunkt = 0;
        int yPunkt = 0;

        int faktor4 = verschiebungX * 700;
        verschiebungX = faktor4 / a;
        int faktor5 = verschiebungY * 700;
        verschiebungY = faktor5 / b;


        for (int s=0; s<800; s++)
        {

          zeichenFlaeche.setzePunkt(5, x+xPunkt+(-verschiebungX), y-yPunkt-verschiebungY);
          zeichenFlaeche.setzePunkt(5, x-xPunkt+(-verschiebungX), y-yPunkt-verschiebungY);

          xPunkt++;
          
          yPunkt = ((xPunkt * xPunkt) / (100 * 100)) * 100;

        }


      }
```


----------



## Cyz44 (27. Jun 2012)

wäre wirklich sehr gut wenn am besten jetzt noch jemand antworten könnte!


----------



## casi91 (27. Jun 2012)

Morgen.
Wenn deine Linie nur int-Werte zeichnen kann, könntest du den Wert über 
	
	
	
	





```
Math.round
```
 runden.
Du musst dabei aber bedenken, dass es nunmal vorkommen kann, dass eine Funktion ein Ergebnis mit Nachkommastellen hat und wenn du das ganze rundest, wird deine Parabel o.ä. ungenau.

Wenn ich gerade etwas falsch verstehe, entschuldigung. Aber ich muss erst mal warm laufen


----------



## jgh (27. Jun 2012)

wo kommen Kommazahlen raus?
klar bei deinen Rechnungen, aber da deine Variablen alle vom Typ int sind....hast du doch nur int´s, also ganzzahlen!? 


```
int i = 13;
		int j = 2;
		System.out.println(i / j);
```
Ausgabe=6


----------

