Java Taschenrechner

[Zyron]

Hallo!

Ich programmiere momentan einen kleinen Java Taschenrechner und wollte fragen, ob es dafür vorgefertigte Methoden gibt, die ich einen String einlesen lassen kann und diese mir dann das Ergebnis ausgeben. Man sollte damit auch Klammer, Potenz, Wurzel, sin, cos und tan ausrechnen können. Meine Google Suche hat leider keine solche Ergebnisse geliefert, da man bei jeder dieser vorgefertigten Klassen immer nur einzelne Sachen ausrechnen konnte.

Dankeschön im Voraus!

 

[Tarrew]

Um das nochmal zu wiederholen:
Du programmierst einen Taschenrechner und suchst praktisch eine Methode die alles für dich macht? Was bleibt dir dann noch an Arbeit? Also man könnte sowas uU. sehr umständlich über String parsen machen etc.
Oder direkt die JavaScript Engine nutzen:

        Scanner s = new Scanner(System.in);
        System.out.println("Bitte Rechnung eingeben");
        String rechnung = s.nextLine();
      
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("JavaScript");
        try {
            System.out.println(engine.eval(rechnung));
        } catch (ScriptException e) {
            System.out.println("Ungültige Rechnung");
        }

sin, cos etc. muss man schreiben als "Math.sin" und "Math.cos".

Alternativ lässt man sich mit Antlr oÄ einen Lexer und einen Parser generieren und arbeitet damit.
Ich hab das damals für/mit einem User gemacht, der etwas Ähnliches vorhatte.
Siehe:
http://www.java-forum.org/thema/klammerberechnungen-bei-einem-taschenrechner.165828/

 

[Zyron]

Danke für deinen Beitrag!

Ja, die Sricptengine kenne ich, aber mein Informatiklehrer sagte mir, es gäbe auch Math Parser von anderen Programmierern, die diese schon programmiert haben und da habe ich auch welche gefunden (Open Source), und er meinte, da könne man die komplette rechnung einwerfen und bekommt das Ergebnis wieder heraus, kennt jemand solche?

 

[Tarrew]

Zum Beispiel expr:

        Scanner s = new Scanner(System.in);
        System.out.println("Bitte Rechnung eingeben");
        String rechnung = s.nextLine();
        try {
            Expr expr = Parser.parse(rechnung);
            System.out.println("Ergebnis: " +expr.value());
        } catch (SyntaxException e) {
            System.out.println("Ungültige Rechnung: "+ e.explain());
        }

Ansonsten JEval.

 

[Zyron]

Ok, werde ich mal ausprobieren, danke!

 

[kneitzel]

Ansonsten gibt es auch schon fertig programmierte Taschenrechner in Java. Dann muss man die auch nicht selbst entwickeln.

Die Frage ist, was man hier erwartet. Wenn es um die Interpretation einer Eingabe geht, dann kann das schon sehr komplex sein. Wenn man sich mit der Auswertung beschäftigen will, dann kann man "leichter" anfangen, indem man z.B. eine Prefix Schreibweise für Operationen implementiert. Dann ist das Parsen um einiges leichter und es gibt keine Probleme mit Punkt vor Strichrechnung und all sowas.

Also statt 3 + 4 + 5 wäre die Schreibweise + + 3 4 5 (Also erst 3 + 4 und dann + 5)

Sowas ist recht einfach zu Parsen, da Du einen relativ einfachen Baum hast. Der Baum hat Knoten aus Operatoren (die alle eine feste Nummer an Unterelementen hat) oder eben ein Blatt, das immer eine Zahl sein muss.

Also parst Du einfach, indem du den String von vorne nach hinten durchgehst (Das ist hier schön möglich!)
Du könntest hier einen Tokenizer schreiben, der Eingaben erst einmal in Token verwandelt. Bei + + 3 4 5 wären das die Token "Operator +, "Operator +, Zahl 3, Zahl 4 und Zahl 5.

Wenn Du dann die Token hast, dann brauchst Du auf den Token eine "getNextToken" oder so. Und dann baust Du den Operations-Baum einfach auf:

Der Parse hat dann eine Funktion, die die Token-Liste bekommt und einen (Teil)-Baum zurück gibt.
In diesem Fall würde der Parser dann das Token der Operation + sehen und einen Additions-Knoten erzeugen. Dann wird im Knoten das Parse aufgerufen. Dieses ruft dann einfach erneut dieses Parse Funktion auf und bekommt dann halt wieder ein Additions-Knoten u.s.w.

Der Baum hat dann einen Additionsknoten mit zwei Unterknoten. Der erste Unterknoten ist dann wieder eine Addition mit den Zwei Unterknoten 3 und 4 und der zweite Unterknoten ist dann die 5.

Calculate() auf dem Knoten ist dann eine Funktion, die jeder Knoten haben muss. Bei der addition wird dann halt calculate auf beiden Unterknoten aufgerufen und die Addition beider Ergebnisse zurück gegeben. Bei einem Zahlenknoten wird nur die Zahl zurück gegeben.

Ich hoffe, die Erklärung war halbwegs verständlich. Das wäre eine Implementation, die man selbst recht gut bauen kann.

Alle anderen Dinge sind etwas komplizierter. Die Infix Notation, die wir gewohnt sind, macht alles deutlich komplexer und ist als eine einfache Aufgabe deutlich zu komplex. Wenn dies aber eine Sache ist, die dich interessiert, dann würde ich Dir das Drachenmodel empfehlen (Wobei ich nicht sicher bin, ob das noch aktuell ist. Ich habe mich damit halt vor über 20 Jahren beschäftigt und damals ein Buch mit zwei Bänden dazu durchgearbeitet.) Was ich diesbezüglich gefunden habe wäre z.B. http://dragonbook.stanford.edu/

Man kann natürlich einfach die angebotenen Tools verwenden, ohne zu verstehen, was die genau machen, aber ist etwas, das mir oft widerstrebt. Denn wenn es Probleme und Nebeneffekte gibt, möchte ich diese ja schon verstehen und meine Lösung voll supporten. (Für eine kleine Aufgabe ist dies natürlich nicht so relevant wie bei einem Produkt, welches eingesetzt wird und für den es einen 3rd Level Support gibt der alle Fälle abhandeln können muss.)

(Diesen Parser für Präfix Notation haben wir damals übrigens auch im Rahmen des Informatik Unterrichts geschrieben. Das ist also eine Sache, die sehr gut und einfach in dem kleineren Rahmen möglich ist!)

Konrad

 

[Zyron]

Danke für deine Alternative, werde mich in Zukunft damit beschäftigen und habe auch schon einen ohne solch eine fertige Klasse gemacht, jedoch sollte dies nur ein sehr kleines Projekt sein und bleiben, weshalb ich JEval dafür genutzt habe.