Add a binary number type based on the naive number.

src/main/java/org/nwapw/abacus/Abacus.java

@@ -1,6 +1,7 @@
 package org.nwapw.abacus;
 
 import org.nwapw.abacus.config.ConfigurationObject;
+import org.nwapw.abacus.fx.AbacusApplication;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.parsing.LexerTokenizer;
@@ -11,9 +12,7 @@ import org.nwapw.abacus.plugin.PluginManager;
 import org.nwapw.abacus.plugin.StandardPlugin;
 import org.nwapw.abacus.tree.NumberReducer;
 import org.nwapw.abacus.tree.TreeNode;
-import org.nwapw.abacus.window.Window;
 
-import javax.swing.*;
 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
@@ -79,13 +78,7 @@ public class Abacus {
     }
 
     public static void main(String[] args) {
-        try {
+        AbacusApplication.launch(AbacusApplication.class, args);
-            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
-        } catch (ClassNotFoundException | InstantiationException | UnsupportedLookAndFeelException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-
-        new Window(new Abacus()).setVisible(true);
     }
 
     /**

src/main/java/org/nwapw/abacus/fx/AbacusApplication.java

@@ -0,0 +1,24 @@
+package org.nwapw.abacus.fx;
+
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+
+/**
+ * The main application class for JavaFX responsible for loading
+ * and displaying the fxml file.
+ */
+public class AbacusApplication extends Application {
+
+    @Override
+    public void start(Stage primaryStage) throws Exception {
+        Parent parent = FXMLLoader.load(getClass().getResource("/abacus.fxml"));
+        Scene mainScene = new Scene(parent, 320, 480);
+        primaryStage.setScene(mainScene);
+        primaryStage.setTitle("Abacus");
+        primaryStage.show();
+    }
+
+}

src/main/java/org/nwapw/abacus/fx/AbacusController.java

@@ -0,0 +1,94 @@
+package org.nwapw.abacus.fx;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.fxml.FXML;
+import javafx.scene.control.*;
+import javafx.scene.text.Text;
+import javafx.util.Callback;
+import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.tree.TreeNode;
+
+
+/**
+ * The controller for the abacus FX UI, responsible
+ * for all the user interaction.
+ */
+public class AbacusController {
+
+    /**
+     * Constant string that is displayed if the text could not be lexed or parsed.
+     */
+    private static final String ERR_SYNTAX = "Syntax Error";
+    /**
+     * Constant string that is displayed if the tree could not be reduced.
+     */
+    private static final String ERR_EVAL = "Evaluation Error";
+
+    @FXML
+    private TableView<HistoryModel> historyTable;
+    @FXML
+    private TableColumn<HistoryModel, String> inputColumn;
+    @FXML
+    private TableColumn<HistoryModel, String> parsedColumn;
+    @FXML
+    private TableColumn<HistoryModel, String> outputColumn;
+    @FXML
+    private Text outputText;
+    @FXML
+    private TextField inputField;
+    @FXML
+    private Button inputButton;
+
+    /**
+     * The list of history entries, created by the users.
+     */
+    private ObservableList<HistoryModel> historyData;
+
+    /**
+     * The abacus instance used for calculations and all
+     * other main processing code.
+     */
+    private Abacus abacus;
+
+    @FXML
+    public void initialize(){
+        Callback<TableColumn<HistoryModel, String>, TableCell<HistoryModel, String>> cellFactory =
+                param -> new CopyableCell<>();
+
+        abacus = new Abacus();
+        historyData = FXCollections.observableArrayList();
+        historyTable.setItems(historyData);
+        historyTable.getSelectionModel().setCellSelectionEnabled(true);
+        inputColumn.setCellFactory(cellFactory);
+        inputColumn.setCellValueFactory(cell -> cell.getValue().inputProperty());
+        parsedColumn.setCellFactory(cellFactory);
+        parsedColumn.setCellValueFactory(cell -> cell.getValue().parsedProperty());
+        outputColumn.setCellFactory(cellFactory);
+        outputColumn.setCellValueFactory(cell -> cell.getValue().outputProperty());
+    }
+
+    @FXML
+    private void performCalculation(){
+        inputButton.setDisable(true);
+        TreeNode constructedTree = abacus.parseString(inputField.getText());
+        if(constructedTree == null){
+            outputText.setText(ERR_SYNTAX);
+            inputButton.setDisable(false);
+            return;
+        }
+        NumberInterface evaluatedNumber = abacus.evaluateTree(constructedTree);
+        if(evaluatedNumber == null){
+            outputText.setText(ERR_EVAL);
+            inputButton.setDisable(false);
+            return;
+        }
+        outputText.setText(evaluatedNumber.toString());
+        historyData.add(new HistoryModel(inputField.getText(), constructedTree.toString(), evaluatedNumber.toString()));
+
+        inputButton.setDisable(false);
+        inputField.setText("");
+    }
+
+}

src/main/java/org/nwapw/abacus/fx/CopyableCell.java

@@ -0,0 +1,35 @@
+package org.nwapw.abacus.fx;
+
+import javafx.scene.control.TableCell;
+import javafx.scene.input.MouseEvent;
+
+import java.awt.*;
+import java.awt.datatransfer.StringSelection;
+
+/**
+ * A cell that copies its value to the clipboard
+ * when double clicked.
+ * @param <S> The type of the table view generic type.
+ * @param <T> The type of the value contained in the cell.
+ */
+public class CopyableCell<S, T> extends TableCell<S, T> {
+
+    /**
+     * Creates a new copyable cell.
+     */
+    public CopyableCell(){
+        addEventFilter(MouseEvent.MOUSE_CLICKED, event -> {
+            if(event.getClickCount() == 2){
+                Toolkit.getDefaultToolkit().getSystemClipboard()
+                        .setContents(new StringSelection(getText()), null);
+            }
+        });
+    }
+
+    @Override
+    protected void updateItem(T item, boolean empty) {
+        super.updateItem(item, empty);
+        setText((empty || item == null) ? null : item.toString());
+        setGraphic(null);
+    }
+}

src/main/java/org/nwapw/abacus/fx/HistoryModel.java

@@ -0,0 +1,87 @@
+package org.nwapw.abacus.fx;
+
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+
+/**
+ * The data model used for storing history entries.
+ */
+public class HistoryModel {
+
+    /**
+     * The property used for displaying the column
+     * for the user input.
+     */
+    private final StringProperty input;
+    /**
+     * The property used for displaying the column
+     * that contains the parsed input.
+     */
+    private final StringProperty parsed;
+    /**
+     * The property used for displaying the column
+     * that contains the program output.
+     */
+    private final StringProperty output;
+
+    /**
+     * Creates a new history model with the given variables.
+     * @param input the user input
+     * @param parsed the parsed input
+     * @param output the program output.
+     */
+    public HistoryModel(String input, String parsed, String output){
+        this.input = new SimpleStringProperty();
+        this.parsed = new SimpleStringProperty();
+        this.output = new SimpleStringProperty();
+        this.input.setValue(input);
+        this.parsed.setValue(parsed);
+        this.output.setValue(output);
+    }
+
+    /**
+     * Gets the input property.
+     * @return the input property.
+     */
+    public StringProperty inputProperty() {
+        return input;
+    }
+    /**
+     * Gets the input.
+     * @return the input.
+     */
+    public String getInput() {
+        return input.get();
+    }
+
+    /**
+     * Gets the parsed input property.
+     * @return the parsed input property.
+     */
+    public StringProperty parsedProperty() {
+        return parsed;
+    }
+    /**
+     * Gets the parsed input.
+     * @return the parsed input.
+     */
+    public String getParsed() {
+        return parsed.get();
+    }
+
+    /**
+     * Gets the output property.
+     * @return the output property.
+     */
+    public StringProperty outputProperty() {
+        return output;
+    }
+    /**
+     * Gets the program output.
+     * @return the output.
+     */
+    public String getOutput() {
+        return output.get();
+    }
+
+}

src/main/java/org/nwapw/abacus/number/BinaryNumber.java

@@ -0,0 +1,162 @@
+package org.nwapw.abacus.number;
+
+public class BinaryNumber implements NumberInterface{
+
+    /**
+     * The number zero.
+     */
+    public static final BinaryNumber ZERO = new BinaryNumber(0);
+    /**
+     * The number one.
+     */
+    public static final BinaryNumber ONE = new BinaryNumber(1);
+    /**
+     * The value of this number.
+     */
+    private double value;
+
+    /**
+     * Creates a new BinaryNumber with the given string.
+     *
+     * @param value the value, which will be parsed as a double.
+     */
+    public BinaryNumber(String value) {
+        toStandard(value);
+    }
+    /**
+     * 
+     */
+    private void toStandard(String value) {
+        String before;
+        String after = "";
+        if(value.indexOf(".")==-1){
+            before=value;
+        }else{
+            before = value.substring(0,value.indexOf("."));
+            after = value.substring(value.indexOf(".")+1);
+        }
+        double sum = 0;
+        for(int it=0;before.length()>0;it++){
+            if(before.charAt(before.length()-1)=='1'){
+                sum+=Math.pow(2,it);
+            }
+            if(before.length()>1) {
+                before = before.substring(0, before.length()-1);
+            }else{
+                before = "";
+            }
+        }
+        for(int it=-1;after.length()>0;it--) {
+            if (after.charAt(0) == '1') {
+                sum += Math.pow(2, it);
+            }
+            if (after.length() > 1) {
+                after = after.substring(1);
+            } else {
+                after = "";
+            }
+        }
+
+        this.value = sum;
+    }
+    
+    /**
+     * Creates a new BinaryNumber with the given value.
+     *
+     * @param value the value to use.
+     */
+    public BinaryNumber(double value) {
+        toStandard(""+value);
+    }
+
+    @Override
+    public int getMaxPrecision() {
+        return 18;
+    }
+
+    @Override
+    public NumberInterface multiply(NumberInterface multiplier) {
+        return new BinaryNumber(value * ((BinaryNumber) multiplier).value);
+    }
+
+    @Override
+    public NumberInterface divide(NumberInterface divisor) {
+        return new BinaryNumber(value / ((BinaryNumber) divisor).value);
+    }
+
+    @Override
+    public NumberInterface add(NumberInterface summand) {
+        return new BinaryNumber(value + ((BinaryNumber) summand).value);
+    }
+
+    @Override
+    public NumberInterface subtract(NumberInterface subtrahend) {
+        return new BinaryNumber(value - ((BinaryNumber) subtrahend).value);
+    }
+
+    @Override
+    public NumberInterface negate() {
+        return new BinaryNumber(-value);
+    }
+
+    @Override
+    public NumberInterface intPow(int exponent) {
+        if (exponent == 0) {
+            return BinaryNumber.ONE;
+        }
+        boolean takeReciprocal = exponent < 0;
+        exponent = Math.abs(exponent);
+        NumberInterface power = this;
+        for (int currentExponent = 1; currentExponent < exponent; currentExponent++) {
+            power = power.multiply(this);
+        }
+        if (takeReciprocal) {
+            power = BinaryNumber.ONE.divide(power);
+        }
+        return power;
+    }
+
+    @Override
+    public int compareTo(NumberInterface number) {
+        BinaryNumber num = (BinaryNumber) number;
+        return Double.compare(value, num.value);
+    }
+
+    @Override
+    public int signum() {
+        return this.compareTo(ZERO);
+    }
+
+    @Override
+    public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
+        if (toClass == this.getClass()) return this;
+        else if (toClass == PreciseNumber.class) {
+            return new PreciseNumber(Double.toString(value));
+        }
+        return null;
+    }
+
+    public String toString() {
+        double sum = 0;
+        double tempValue = Math.floor(value);
+        double fraction = value-tempValue;
+        for (int it=0;tempValue > 0;it++) {
+
+            if (tempValue % 2 == 1) {
+                sum+=Math.pow(10,it);
+                tempValue-=1;
+            }
+            tempValue=tempValue/2;
+        }
+        for (int it=0;fraction > 0;it--) {
+
+            if (fraction % 2 >= 1) {
+                sum+=Math.pow(10,it);
+                fraction-=1;
+            }
+            fraction=fraction*2;
+        }
+        double shiftBy = Math.pow(10, 10);
+        return Double.toString(Math.round(sum * shiftBy) / shiftBy);
+    }
+}

src/main/java/org/nwapw/abacus/number/PreciseNumber.java

@@ -1,9 +1,12 @@
 package org.nwapw.abacus.number;
 
 import java.math.BigDecimal;
-import java.math.MathContext;
 import java.math.RoundingMode;
 
+/**
+ * A number that uses a BigDecimal to store its value,
+ * leading to infinite possible precision.
+ */
 public class PreciseNumber implements NumberInterface {
 
     /**
@@ -45,7 +48,7 @@ public class PreciseNumber implements NumberInterface {
 
     @Override
     public int getMaxPrecision() {
-        return 54;
+        return 65;
     }
 
     @Override
@@ -115,7 +118,7 @@ public class PreciseNumber implements NumberInterface {
 
     @Override
     public String toString() {
-        BigDecimal rounded = value.setScale(getMaxPrecision() - 4, RoundingMode.HALF_UP);
+        BigDecimal rounded = value.setScale(getMaxPrecision() - 15, RoundingMode.HALF_UP);
         return rounded.stripTrailingZeros().toPlainString();
     }
 }

src/main/resources/abacus.fxml

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.BorderPane?>
+<?import javafx.scene.layout.VBox?>
+<?import javafx.scene.text.Text?>
+<BorderPane xmlns="http://javafx.com/javafx"
+            xmlns:fx="http://javafx.com/fxml"
+            fx:controller="org.nwapw.abacus.fx.AbacusController">
+    <center>
+        <TabPane>
+            <Tab text="Calculator" closable="false">
+                <BorderPane>
+                    <center>
+                        <TableView fx:id="historyTable">
+                            <columnResizePolicy>
+                                <TableView fx:constant="CONSTRAINED_RESIZE_POLICY"/>
+                            </columnResizePolicy>
+                            <columns>
+                                <TableColumn fx:id="inputColumn" text="Input" sortable="false"/>
+                                <TableColumn fx:id="parsedColumn" text="Parsed" sortable="false"/>
+                                <TableColumn fx:id="outputColumn" text="Output" sortable="false"/>
+                            </columns>
+                        </TableView>
+                    </center>
+                    <bottom>
+                        <VBox>
+                            <ScrollPane prefHeight="50" vbarPolicy="NEVER">
+                                <padding>
+                                    <Insets top="10" bottom="10" left="10" right="10"/>
+                                </padding>
+                                <Text fx:id="outputText"/>
+                            </ScrollPane>
+                            <TextField fx:id="inputField" onAction="#performCalculation"/>
+                            <Button fx:id="inputButton" text="Calculate" maxWidth="Infinity"
+                                    onAction="#performCalculation"/>
+                        </VBox>
+                    </bottom>
+                </BorderPane>
+            </Tab>
+            <Tab text="Settings" closable="false"/>
+        </TabPane>
+    </center>
+
+</BorderPane>