add macros

# Conflicts:
#	src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java

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

@@ -2,20 +2,19 @@ package org.nwapw.abacus;
 
 import org.nwapw.abacus.config.Configuration;
 import org.nwapw.abacus.fx.AbacusApplication;
+import org.nwapw.abacus.fx.AbacusController;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.parsing.LexerTokenizer;
 import org.nwapw.abacus.parsing.ShuntingYardParser;
 import org.nwapw.abacus.parsing.TreeBuilder;
-import org.nwapw.abacus.plugin.ClassFinder;
+import org.nwapw.abacus.plugin.NumberImplementation;
 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 java.io.File;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
 
 /**
  * The main calculator class. This is responsible
@@ -25,13 +24,9 @@ import java.lang.reflect.InvocationTargetException;
 public class Abacus {
 
     /**
-     * The default implementation to use for the number representation.
+     * The default number implementation to be used if no other one is available / selected.
      */
-    public static final Class<? extends NumberInterface> DEFAULT_NUMBER = NaiveNumber.class;
-    /**
-     * The file used for saving and loading configuration.
-     */
-    public static final File CONFIG_FILE = new File("config.toml");
+    public static final NumberImplementation DEFAULT_IMPLEMENTATION = StandardPlugin.IMPLEMENTATION_NAIVE;
 
     /**
      * The plugin manager responsible for
@@ -52,31 +47,28 @@ public class Abacus {
      * from a string.
      */
     private TreeBuilder treeBuilder;
-
+    private AbacusController controller;
     /**
      * Creates a new instance of the Abacus calculator.
+     *
+     * @param configuration the configuration object for this Abacus instance.
      */
-    public Abacus() {
+    public Abacus(Configuration configuration,AbacusController controller) {
         pluginManager = new PluginManager(this);
         numberReducer = new NumberReducer(this);
-        configuration = new Configuration(CONFIG_FILE);
-        configuration.saveTo(CONFIG_FILE);
+        this.configuration = new Configuration(configuration);
         LexerTokenizer lexerTokenizer = new LexerTokenizer();
         ShuntingYardParser shuntingYardParser = new ShuntingYardParser(this);
         treeBuilder = new TreeBuilder<>(lexerTokenizer, shuntingYardParser);
 
-        pluginManager.addListener(lexerTokenizer);
         pluginManager.addListener(shuntingYardParser);
-        pluginManager.addInstantiated(new StandardPlugin(pluginManager));
-        try {
-            ClassFinder.loadJars("plugins")
-                    .forEach(plugin -> pluginManager.addClass(plugin));
-        } catch (IOException | ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-        pluginManager.load();
-    }
+        pluginManager.addListener(lexerTokenizer);
+        this.controller =controller;
 
+    }
+    public NumberInterface getVar(String variable){
+        return controller.getVar(variable);
+    }
     public static void main(String[] args) {
         AbacusApplication.launch(AbacusApplication.class, args);
     }
@@ -147,15 +139,10 @@ public class Abacus {
      * @return the resulting number.
      */
     public NumberInterface numberFromString(String numberString) {
-        Class<? extends NumberInterface> toInstantiate =
-                pluginManager.numberFor(configuration.getNumberImplementation());
-        if (toInstantiate == null) toInstantiate = DEFAULT_NUMBER;
+        NumberImplementation toInstantiate =
+                pluginManager.numberImplementationFor(configuration.getNumberImplementation());
+        if (toInstantiate == null) toInstantiate = DEFAULT_IMPLEMENTATION;
 
-        try {
-            return toInstantiate.getConstructor(String.class).newInstance(numberString);
-        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return null;
+        return toInstantiate.instanceForString(numberString);
     }
 }

src/main/java/org/nwapw/abacus/config/Configuration.java

@@ -20,7 +20,7 @@ public class Configuration {
      */
     private static final String DEFAULT_CONFIG =
             "numberImplementation = \"naive\"\n" +
-            "disabledPlugins = []";
+                    "disabledPlugins = []";
     /**
      * The defaults TOML object, parsed from the string.
      */
@@ -30,6 +30,10 @@ public class Configuration {
      */
     private static final TomlWriter TOML_WRITER = new TomlWriter();
 
+    /**
+     * The computation delay for which the thread can run without interruption.
+     */
+    private double computationDelay = 0;
     /**
      * The implementation of the number that should be used.
      */
@@ -40,29 +44,44 @@ public class Configuration {
     private Set<String> disabledPlugins = new HashSet<>();
 
     /**
-     * Creates a new configuration with the given values.
-     * @param numberImplementation the number implementation, like "naive" or "precise"
-     * @param disabledPlugins the list of disabled plugins.
+     * Creates a new configuration form the given configuration.
+     *
+     * @param copyFrom the configuration to copy.
      */
-    public Configuration(String numberImplementation, String[] disabledPlugins){
+    public Configuration(Configuration copyFrom){
+        copyFrom(copyFrom);
+    }
+
+    /**
+     * Creates a new configuration with the given values.
+     *
+     * @param computationDelay     the delay before the computation gets killed.
+     * @param numberImplementation the number implementation, like "naive" or "precise"
+     * @param disabledPlugins      the list of disabled plugins.
+     */
+    public Configuration(double computationDelay, String numberImplementation, String[] disabledPlugins) {
+        this.computationDelay = computationDelay;
         this.numberImplementation = numberImplementation;
         this.disabledPlugins.addAll(Arrays.asList(disabledPlugins));
     }
 
     /**
      * Loads a configuration from a given file, keeping non-specified fields default.
+     *
      * @param fromFile the file to load from.
      */
-    public Configuration(File fromFile){
-        if(!fromFile.exists()) return;
+    public Configuration(File fromFile) {
+        if (!fromFile.exists()) return;
         copyFrom(new Toml(DEFAULT_TOML).read(fromFile).to(Configuration.class));
     }
 
     /**
      * Copies the values from the given configuration into this one.
+     *
      * @param otherConfiguration the configuration to copy from.
      */
-    public void copyFrom(Configuration otherConfiguration){
+    public void copyFrom(Configuration otherConfiguration) {
+        this.computationDelay = otherConfiguration.computationDelay;
         this.numberImplementation = otherConfiguration.numberImplementation;
         this.disabledPlugins.addAll(otherConfiguration.disabledPlugins);
     }
@@ -70,10 +89,11 @@ public class Configuration {
     /**
      * Saves this configuration to the given file, creating
      * any directories that do not exist.
+     *
      * @param file the file to save to.
      */
-    public void saveTo(File file){
-        if(file.getParentFile() != null) file.getParentFile().mkdirs();
+    public void saveTo(File file) {
+        if (file.getParentFile() != null) file.getParentFile().mkdirs();
         try {
             TOML_WRITER.write(this, file);
         } catch (IOException e) {
@@ -81,8 +101,18 @@ public class Configuration {
         }
     }
 
+    /**
+     * Gets the value of this configuration as a string.
+     *
+     * @return the string that represents this configuration.
+     */
+    public String asTomlString(){
+        return TOML_WRITER.write(this);
+    }
+
     /**
      * Gets the number implementation from this configuration.
+     *
      * @return the number implementation.
      */
     public String getNumberImplementation() {
@@ -91,6 +121,7 @@ public class Configuration {
 
     /**
      * Sets the number implementation for the configuration
+     *
      * @param numberImplementation the number implementation.
      */
     public void setNumberImplementation(String numberImplementation) {
@@ -99,10 +130,30 @@ public class Configuration {
 
     /**
      * Gets the list of disabled plugins.
+     *
      * @return the list of disabled plugins.
      */
     public Set<String> getDisabledPlugins() {
         return disabledPlugins;
     }
 
+
+    /**
+     * Gets the computation delay specified in the configuration.
+     *
+     * @return the computaton delay.
+     */
+    public double getComputationDelay() {
+        return computationDelay;
+    }
+
+    /**
+     * Sets the computation delay.
+     *
+     * @param computationDelay the new computation delay.
+     */
+    public void setComputationDelay(double computationDelay) {
+        this.computationDelay = computationDelay;
+    }
+
 }

src/main/java/org/nwapw/abacus/function/Function.java

@@ -1,10 +1,6 @@
 package org.nwapw.abacus.function;
 
-import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
-import org.nwapw.abacus.number.PreciseNumber;
-
-import java.util.HashMap;
 
 /**
  * A function that operates on one or more
@@ -12,15 +8,6 @@ import java.util.HashMap;
  */
 public abstract class Function {
 
-    /**
-     * A map to correctly promote different number implementations to each other.
-     */
-    private static final HashMap<Class<? extends NumberInterface>, Integer> priorityMap =
-            new HashMap<Class<? extends NumberInterface>, Integer>() {{
-                put(NaiveNumber.class, 0);
-                put(PreciseNumber.class, 1);
-            }};
-
     /**
      * Checks whether the given params will work for the given function.
      *

src/main/java/org/nwapw/abacus/function/Operator.java

@@ -26,6 +26,7 @@ public class Operator {
      * Creates a new operator with the given parameters.
      *
      * @param associativity the associativity of the operator.
+     * @param operatorType  the type of this operator, like binary infix or unary postfix.
      * @param precedence    the precedence of the operator.
      * @param function      the function that the operator calls.
      */

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

@@ -12,13 +12,25 @@ import javafx.stage.Stage;
  */
 public class AbacusApplication extends Application {
 
+    /**
+     * The controller currently managing the application.
+     */
+    private AbacusController controller;
+
     @Override
     public void start(Stage primaryStage) throws Exception {
-        Parent parent = FXMLLoader.load(getClass().getResource("/abacus.fxml"));
+        FXMLLoader loader = new FXMLLoader(getClass().getResource("/abacus.fxml"));
+        Parent parent = loader.load();
+        controller = loader.getController();
         Scene mainScene = new Scene(parent, 320, 480);
         primaryStage.setScene(mainScene);
         primaryStage.setTitle("Abacus");
         primaryStage.show();
     }
 
+    @Override
+    public void stop() throws Exception {
+        super.stop();
+        controller.performStop();
+    }
 }

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

@@ -1,5 +1,6 @@
 package org.nwapw.abacus.fx;
 
+import javafx.application.Platform;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 import javafx.fxml.FXML;
@@ -10,11 +11,16 @@ import javafx.util.Callback;
 import javafx.util.StringConverter;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.config.Configuration;
+import org.nwapw.abacus.number.ComputationInterruptedException;
+import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
-import org.nwapw.abacus.plugin.PluginListener;
-import org.nwapw.abacus.plugin.PluginManager;
+import org.nwapw.abacus.plugin.*;
 import org.nwapw.abacus.tree.TreeNode;
 
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Scanner;
 import java.util.Set;
 
 
@@ -24,6 +30,10 @@ import java.util.Set;
  */
 public class AbacusController implements PluginListener {
 
+    /**
+     * The file used for saving and loading configuration.
+     */
+    public static final File CONFIG_FILE = new File("config.toml");
     /**
      * The title for the apply alert dialog.
      */
@@ -36,7 +46,7 @@ public class AbacusController implements PluginListener {
      * The text for the dialog that is shown if settings haven't been applied.
      */
     private static final String APPLY_MSG_TEXT = "You have made changes to the configuration, however, you haven't pressed \"Apply\". " +
-                "The changes to the configuration will not be present in the calculator until \"Apply\" is pressed.";
+            "The changes to the configuration will not be present in the calculator until \"Apply\" is pressed.";
     /**
      * Constant string that is displayed if the text could not be lexed or parsed.
      */
@@ -45,7 +55,24 @@ public class AbacusController implements PluginListener {
      * Constant string that is displayed if the tree could not be reduced.
      */
     private static final String ERR_EVAL = "Evaluation Error";
-
+    /**
+     * Constant string that is displayed if the calculations are stopped before they are done.
+     */
+    private static final String ERR_STOP = "Stopped";
+    /**
+     * Constant string that is displayed if the calculations are interrupted by an exception.
+     */
+    private static final String ERR_EXCEPTION = "Exception Thrown";
+    @FXML
+    private TextArea macroOutputField;
+    @FXML
+    private Tab macroTab;
+    @FXML
+    private TextArea macroField;
+    @FXML
+    private Button inputButtonMacro;
+    @FXML
+    private Button stopButtonMacro;
     @FXML
     private TabPane coreTabPane;
     @FXML
@@ -67,10 +94,14 @@ public class AbacusController implements PluginListener {
     @FXML
     private Button inputButton;
     @FXML
+    private Button stopButton;
+    @FXML
     private ComboBox<String> numberImplementationBox;
     @FXML
     private ListView<ToggleablePlugin> enabledPluginView;
-
+    @FXML
+    private TextField computationLimitField;
+    private String macroOutputText;
     /**
      * The list of history entries, created by the users.
      */
@@ -92,7 +123,7 @@ public class AbacusController implements PluginListener {
      * The abacus instance used for changing the plugin configuration.
      */
     private Abacus abacus;
-
+    private boolean stop;
     /**
      * Boolean which represents whether changes were made to the configuration.
      */
@@ -105,20 +136,87 @@ public class AbacusController implements PluginListener {
      * The alert shown when a press to "apply" is needed.
      */
     private Alert reloadAlert;
+    private ArrayList<Plugin> plugins;
+    public NumberInterface getVar(String variable){
+        for(Plugin plugin:plugins){
+            if(plugin instanceof VariablePlugin){
+                if(((VariablePlugin)plugin).getValue(variable)!=null)
+                    return ((VariablePlugin)plugin).getValue(variable);
+                return NaiveNumber.ZERO;
+            }
+        }
+        return null;
+    }
+    /**
+     * The runnable that takes care of killing computations that take too long.
+     */
+    private final Runnable TIMER_RUNNABLE = () -> {
+        try {
+            Configuration abacusConfig = abacus.getConfiguration();
+            if(abacusConfig.getComputationDelay() == 0) return;
+            Thread.sleep((long) (abacusConfig.getComputationDelay() * 1000));
+            performStop();
+        } catch (InterruptedException e) { }
+    };
+    /**
+     * The runnable used to perform the calculation.
+     */
+    private final Runnable CALCULATION_RUNNABLE = new Runnable() {
+
+        private String attemptCalculation(){
+            try {
+                TreeNode constructedTree = abacus.parseString(inputField.getText());
+                if (constructedTree == null) {
+                    return ERR_SYNTAX;
+                }
+                NumberInterface evaluatedNumber = abacus.evaluateTree(constructedTree);
+                if (evaluatedNumber == null) {
+                    return ERR_EVAL;
+                }
+                String resultingString = evaluatedNumber.toString();
+                historyData.add(new HistoryModel(inputField.getText(), constructedTree.toString(), resultingString));
+                return resultingString;
+            } catch (ComputationInterruptedException exception) {
+                return ERR_STOP;
+            } catch (RuntimeException exception){
+                exception.printStackTrace();
+                return ERR_EXCEPTION;
+            }
+        }
+
+        @Override
+        public void run() {
+            String calculation = attemptCalculation();
+            Platform.runLater(() -> {
+                outputText.setText(calculation);
+                inputField.setText("");
+                inputButton.setDisable(false);
+                stopButton.setDisable(true);
+            });
+        }
+    };
+    /**
+     * The thread that is waiting to pause the calculation.
+     */
+    private Thread computationLimitThread;
+    /**
+     * The thread in which the computation runs.
+     */
+    private Thread calculationThread;
 
     /**
      * Alerts the user if the changes they made
      * have not yet been applied.
      */
-    private void alertIfApplyNeeded(boolean ignorePrevious){
-        if(changesMade && (!reloadAlertShown || ignorePrevious)) {
+    private void alertIfApplyNeeded(boolean ignorePrevious) {
+        if (changesMade && (!reloadAlertShown || ignorePrevious)) {
             reloadAlertShown = true;
             reloadAlert.showAndWait();
         }
     }
 
     @FXML
-    public void initialize(){
+    public void initialize() {
         Callback<TableColumn<HistoryModel, String>, TableCell<HistoryModel, String>> cellFactory =
                 param -> new CopyableCell<>();
         Callback<ListView<ToggleablePlugin>, ListCell<ToggleablePlugin>> pluginCellFactory =
@@ -150,12 +248,33 @@ public class AbacusController implements PluginListener {
         outputColumn.setCellFactory(cellFactory);
         outputColumn.setCellValueFactory(cell -> cell.getValue().outputProperty());
         coreTabPane.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> {
-            if(oldValue.equals(settingsTab)) alertIfApplyNeeded(true);
+            if (oldValue.equals(settingsTab)) alertIfApplyNeeded(true);
         });
 
-        abacus = new Abacus();
-        abacus.getPluginManager().addListener(this);
-        abacus.getPluginManager().reload();
+        abacus = new Abacus(new Configuration(CONFIG_FILE),this);
+        PluginManager abacusPluginManager = abacus.getPluginManager();
+        abacusPluginManager.addListener(this);
+        plugins = new ArrayList<>();
+        plugins.add(new StandardPlugin(abacus.getPluginManager()));
+        plugins.add(new VariablePlugin(abacus.getPluginManager()));
+        for(Plugin plugin: plugins){
+            abacusPluginManager.addInstantiated(plugin);
+        }
+        try {
+            ClassFinder.loadJars("plugins").forEach(abacusPluginManager::addClass);
+        } catch (IOException | ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        abacusPluginManager.reload();
+
+        computationLimitField.setText(Double.toString(abacus.getConfiguration().getComputationDelay()));
+        computationLimitField.textProperty().addListener((observable, oldValue, newValue) -> {
+            if(!newValue.matches("(\\d+(\\.\\d*)?)?")) {
+                computationLimitField.setText(oldValue);
+            } else {
+                changesMade = true;
+            }
+        });
 
         changesMade = false;
         reloadAlertShown = false;
@@ -167,29 +286,64 @@ public class AbacusController implements PluginListener {
     }
 
     @FXML
-    private void performCalculation(){
+    public void performCalculation() {
+        stop=false;
         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()));
+        stopButton.setDisable(false);
+        calculationThread = new Thread(CALCULATION_RUNNABLE);
+        calculationThread.start();
+        computationLimitThread = new Thread(TIMER_RUNNABLE);
+        computationLimitThread.start();
+    }
+    Runnable macroCalculate = new Runnable(){
+        @Override
+        public void run() {
+            stop=false;
+            inputButtonMacro.setDisable(true);
+            stopButtonMacro.setDisable(false);
+            Scanner macroScanner = new Scanner(macroField.getText());
+            String next = "!";
+            macroOutputText="";
+            while(!stop&&macroScanner.hasNextLine()) {
+                next = macroScanner.nextLine().trim();
+                if(next.equals(""))
+                    break;
+                inputField.setText(next);
+                calculationThread = new Thread(CALCULATION_RUNNABLE);
+                calculationThread.start();
+                computationLimitThread = new Thread(TIMER_RUNNABLE);
+                computationLimitThread.start();
+                while(calculationThread.isAlive()){}
+                //long b = System.currentTimeMillis();
+                //while(System.currentTimeMillis()-b<10000){}
+                macroOutputText +=outputText.getText()+"\n";
+                //next = macroScanner.nextLine().trim();
+
+            }
+            Platform.runLater(() -> {
+                macroOutputField.setText(macroOutputText);
+                inputButtonMacro.setDisable(false);
+                stopButtonMacro.setDisable(true);
+            });
+        }
+    };
+    @FXML
+    public void macroCalculation(){
+        Thread macroThread = new Thread(macroCalculate);
+        macroThread.start();
+    }
+    @FXML
+    public void performStop(){
+        if(calculationThread != null) {
+            calculationThread.interrupt();
+            calculationThread = null;
+            stop = true;
+        }
 
-        inputButton.setDisable(false);
-        inputField.setText("");
     }
 
     @FXML
-    private void performSaveAndReload(){
+    public void performSaveAndReload() {
         performSave();
         performReload();
         changesMade = false;
@@ -197,21 +351,23 @@ public class AbacusController implements PluginListener {
     }
 
     @FXML
-    private void performReload(){
+    public void performReload() {
         alertIfApplyNeeded(true);
         abacus.getPluginManager().reload();
     }
 
     @FXML
-    private void performSave(){
+    public void performSave() {
         Configuration configuration = abacus.getConfiguration();
         configuration.setNumberImplementation(numberImplementationBox.getSelectionModel().getSelectedItem());
         Set<String> disabledPlugins = configuration.getDisabledPlugins();
         disabledPlugins.clear();
-        for(ToggleablePlugin pluginEntry : enabledPlugins){
-            if(!pluginEntry.isEnabled()) disabledPlugins.add(pluginEntry.getClassName());
+        for (ToggleablePlugin pluginEntry : enabledPlugins) {
+            if (!pluginEntry.isEnabled()) disabledPlugins.add(pluginEntry.getClassName());
         }
-        configuration.saveTo(Abacus.CONFIG_FILE);
+        if(computationLimitField.getText().matches("\\d*(\\.\\d+)?") && computationLimitField.getText().length() != 0)
+            configuration.setComputationDelay(Double.parseDouble(computationLimitField.getText()));
+        configuration.saveTo(CONFIG_FILE);
         changesMade = false;
         reloadAlertShown = false;
     }
@@ -220,11 +376,11 @@ public class AbacusController implements PluginListener {
     public void onLoad(PluginManager manager) {
         Configuration configuration = abacus.getConfiguration();
         Set<String> disabledPlugins = configuration.getDisabledPlugins();
-        numberImplementationOptions.addAll(abacus.getPluginManager().getAllNumbers());
+        numberImplementationOptions.addAll(abacus.getPluginManager().getAllNumberImplementations());
         String actualImplementation = configuration.getNumberImplementation();
         String toSelect = (numberImplementationOptions.contains(actualImplementation)) ? actualImplementation : "<default>";
         numberImplementationBox.getSelectionModel().select(toSelect);
-        for(Class<?> pluginClass : abacus.getPluginManager().getLoadedPluginClasses()){
+        for (Class<?> pluginClass : abacus.getPluginManager().getLoadedPluginClasses()) {
             String fullName = pluginClass.getName();
             ToggleablePlugin plugin = new ToggleablePlugin(!disabledPlugins.contains(fullName), fullName);
             plugin.enabledProperty().addListener(e -> changesMade = true);
@@ -237,4 +393,5 @@ public class AbacusController implements PluginListener {
         enabledPlugins.clear();
         numberImplementationOptions.clear();
     }
+
 }

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

@@ -9,6 +9,7 @@ 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.
  */
@@ -17,9 +18,9 @@ public class CopyableCell<S, T> extends TableCell<S, T> {
     /**
      * Creates a new copyable cell.
      */
-    public CopyableCell(){
+    public CopyableCell() {
         addEventFilter(MouseEvent.MOUSE_CLICKED, event -> {
-            if(event.getClickCount() == 2){
+            if (event.getClickCount() == 2) {
                 Toolkit.getDefaultToolkit().getSystemClipboard()
                         .setContents(new StringSelection(getText()), null);
             }

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

@@ -26,11 +26,12 @@ public class HistoryModel {
 
     /**
      * Creates a new history model with the given variables.
-     * @param input the user input
+     *
+     * @param input  the user input
      * @param parsed the parsed input
      * @param output the program output.
      */
-    public HistoryModel(String input, String parsed, String output){
+    public HistoryModel(String input, String parsed, String output) {
         this.input = new SimpleStringProperty();
         this.parsed = new SimpleStringProperty();
         this.output = new SimpleStringProperty();
@@ -41,13 +42,16 @@ public class HistoryModel {
 
     /**
      * Gets the input property.
+     *
      * @return the input property.
      */
     public StringProperty inputProperty() {
         return input;
     }
+
     /**
      * Gets the input.
+     *
      * @return the input.
      */
     public String getInput() {
@@ -56,13 +60,16 @@ public class HistoryModel {
 
     /**
      * 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() {
@@ -71,13 +78,16 @@ public class HistoryModel {
 
     /**
      * Gets the output property.
+     *
      * @return the output property.
      */
     public StringProperty outputProperty() {
         return output;
     }
+
     /**
      * Gets the program output.
+     *
      * @return the output.
      */
     public String getOutput() {

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

@@ -3,25 +3,56 @@ package org.nwapw.abacus.fx;
 import javafx.beans.property.BooleanProperty;
 import javafx.beans.property.SimpleBooleanProperty;
 
+/**
+ * Class that represents an entry in the plugin check box list.
+ * The changes from this property are written to the config on application.
+ */
 public class ToggleablePlugin {
 
+    /**
+     * The property that determines whether the plugin will be enabled.
+     */
     private final BooleanProperty enabled;
+    /**
+     * The name of the class this entry toggles.
+     */
     private final String className;
 
-    public ToggleablePlugin(boolean enabled, String className){
+    /**
+     * Creates a new toggleable plugin with the given properties.
+     *
+     * @param enabled   the enabled / disabled state at the beginning.
+     * @param className the name of the class this plugin toggles.
+     */
+    public ToggleablePlugin(boolean enabled, String className) {
         this.enabled = new SimpleBooleanProperty();
         this.enabled.setValue(enabled);
         this.className = className;
     }
 
+    /**
+     * Gets the enabled property of this plugin.
+     *
+     * @return the enabled property.
+     */
     public BooleanProperty enabledProperty() {
         return enabled;
     }
 
+    /**
+     * Checks if this plugin entry should be enabled.
+     *
+     * @return whether this plugin will be enabled.
+     */
     public boolean isEnabled() {
         return enabled.get();
     }
 
+    /**
+     * Gets the class name this plugin toggles.
+     *
+     * @return the class name that should be disabled.
+     */
     public String getClassName() {
         return className;
     }

src/main/java/org/nwapw/abacus/lexing/Lexer.java

@@ -57,6 +57,7 @@ public class Lexer<T> {
      * @return the best match.
      */
     public Match<T> lexOne(String from, int startAt, Comparator<T> compare) {
+        //boolean variable = true;
         ArrayList<Match<T>> matches = new ArrayList<>();
         HashSet<PatternNode<T>> currentSet = new HashSet<>();
         HashSet<PatternNode<T>> futureSet = new HashSet<>();
@@ -70,6 +71,7 @@ public class Lexer<T> {
                     node.addOutputsInto(futureSet);
                 } else if (node instanceof EndNode) {
                     matches.add(new Match<>(from.substring(startAt, index), ((EndNode<T>) node).getPatternId()));
+                    //variable = false;
                 }
             }
 
@@ -84,6 +86,9 @@ public class Lexer<T> {
         if (compare != null) {
             matches.sort(Comparator.comparingInt(a -> a.getContent().length()));
         }
+        //if(variable&&) {
+        //    matches.add(new Match<>(from.substring(startAt, index), ((EndNode<T>) node).getPatternId()));
+        //}
         return matches.isEmpty() ? null : matches.get(matches.size() - 1);
     }
 

src/main/java/org/nwapw/abacus/lexing/pattern/Match.java

@@ -1,5 +1,7 @@
 package org.nwapw.abacus.lexing.pattern;
 
+import org.nwapw.abacus.tree.TokenType;
+
 /**
  * A match that has been generated by the lexer.
  *

src/main/java/org/nwapw/abacus/lexing/pattern/ValueNode.java

@@ -15,7 +15,7 @@ public class ValueNode<T> extends PatternNode<T> {
     /**
      * Creates a new node that matches the given character.
      *
-     * @param value
+     * @param value the character value of the node.
      */
     public ValueNode(char value) {
         this.value = value;

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

@@ -0,0 +1,16 @@
+package org.nwapw.abacus.number;
+
+/**
+ * Exception thrown when the computation is interrupted by
+ * the user.
+ */
+public class ComputationInterruptedException extends RuntimeException {
+
+    /**
+     * Creates a new exception of this type.
+     */
+    public ComputationInterruptedException(){
+        super("Computation interrupted by user.");
+    }
+
+}

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

@@ -3,7 +3,7 @@ package org.nwapw.abacus.number;
 /**
  * An implementation of NumberInterface using a double.
  */
-public class NaiveNumber implements NumberInterface {
+public class NaiveNumber extends NumberInterface {
 
     /**
      * The number zero.
@@ -26,6 +26,7 @@ public class NaiveNumber implements NumberInterface {
     public NaiveNumber(String value) {
         this(Double.parseDouble(value));
     }
+
     /**
      * Creates a new NaiveNumber with the given value.
      *
@@ -34,39 +35,38 @@ public class NaiveNumber implements NumberInterface {
     public NaiveNumber(double value) {
         this.value = value;
     }
-
     @Override
     public int getMaxPrecision() {
         return 18;
     }
 
     @Override
-    public NumberInterface multiply(NumberInterface multiplier) {
-        return new NaiveNumber(value * ((NaiveNumber) multiplier).value);
+    public NumberInterface multiplyInternal(NumberInterface multiplier) {
+        return new NaiveNumber(value * ((NaiveNumber) multiplier.number()).value);
     }
 
     @Override
-    public NumberInterface divide(NumberInterface divisor) {
-        return new NaiveNumber(value / ((NaiveNumber) divisor).value);
+    public NumberInterface divideInternal(NumberInterface divisor) {
+        return new NaiveNumber(value / ((NaiveNumber) divisor.number()).value);
     }
 
     @Override
-    public NumberInterface add(NumberInterface summand) {
-        return new NaiveNumber(value + ((NaiveNumber) summand).value);
+    public NumberInterface addInternal(NumberInterface summand) {
+        return new NaiveNumber(value + ((NaiveNumber) summand.number()).value);
     }
 
     @Override
-    public NumberInterface subtract(NumberInterface subtrahend) {
-        return new NaiveNumber(value - ((NaiveNumber) subtrahend).value);
+    public NumberInterface subtractInternal(NumberInterface subtrahend) {
+        return new NaiveNumber(value - ((NaiveNumber) subtrahend.number()).value);
     }
 
     @Override
-    public NumberInterface negate() {
+    public NumberInterface negateInternal() {
         return new NaiveNumber(-value);
     }
 
     @Override
-    public NumberInterface intPow(int exponent) {
+    public NumberInterface intPowInternal(int exponent) {
         if (exponent == 0) {
             return NaiveNumber.ONE;
         }
@@ -84,7 +84,7 @@ public class NaiveNumber implements NumberInterface {
 
     @Override
     public int compareTo(NumberInterface number) {
-        NaiveNumber num = (NaiveNumber) number;
+        NaiveNumber num = (NaiveNumber) number.number();
         return Double.compare(value, num.value);
     }
 
@@ -94,15 +94,32 @@ public class NaiveNumber implements NumberInterface {
     }
 
     @Override
-    public int ceiling() {
-        return (int) Math.ceil(value);
+    public NumberInterface ceilingInternal() {
+        return new NaiveNumber(Math.ceil(value));
     }
 
     @Override
-    public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
+    public NumberInterface floorInternal() {
+        return new NaiveNumber(Math.floor(value));
+    }
+
+    @Override
+    public NumberInterface fractionalPartInternal() {
+        return new NaiveNumber(value - Math.floor(value));
+    }
+
+    @Override
+    public int intValue() {
+        return (int) value;
+    }
+
+    @Override
+    public NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass) {
         if (toClass == this.getClass()) return this;
         else if (toClass == PreciseNumber.class) {
             return new PreciseNumber(Double.toString(value));
+        }else if(toClass == Variable.class){
+            return this;
         }
         return null;
     }

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

@@ -3,14 +3,28 @@ package org.nwapw.abacus.number;
 /**
  * An interface used to represent a number.
  */
-public interface NumberInterface {
+public abstract class NumberInterface {
 
+    /**
+     * Check if the thread was interrupted and
+     * throw an exception to end the computation.
+     */
+    private static void checkInterrupted(){
+        if(Thread.currentThread().isInterrupted())
+            throw new ComputationInterruptedException();
+    }
+    public NumberInterface number(){
+        return this;
+    }
+    public Class<? extends NumberInterface> getClassVal(){
+        return this.getClass();
+    }
     /**
      * The maximum precision to which this number operates.
      *
      * @return the precision.
      */
-    int getMaxPrecision();
+    public abstract int getMaxPrecision();
 
     /**
      * Multiplies this number by another, returning
@@ -19,7 +33,21 @@ public interface NumberInterface {
      * @param multiplier the multiplier
      * @return the result of the multiplication.
      */
-    NumberInterface multiply(NumberInterface multiplier);
+    protected abstract NumberInterface multiplyInternal(NumberInterface multiplier);
+
+    /**
+     * Multiplies this number by another, returning
+     * a new number instance. Also, checks if the
+     * thread has been interrupted, and if so, throws
+     * an exception.
+     *
+     * @param multiplier the multiplier
+     * @return the result of the multiplication.
+     */
+    public final NumberInterface multiply(NumberInterface multiplier){
+        checkInterrupted();
+        return multiplyInternal(multiplier);
+    }
 
     /**
      * Divides this number by another, returning
@@ -28,7 +56,21 @@ public interface NumberInterface {
      * @param divisor the divisor
      * @return the result of the division.
      */
-    NumberInterface divide(NumberInterface divisor);
+    protected abstract NumberInterface divideInternal(NumberInterface divisor);
+
+    /**
+     * Divides this number by another, returning
+     * a new number instance. Also, checks if the
+     * thread has been interrupted, and if so, throws
+     * an exception.
+     *
+     * @param divisor the divisor
+     * @return the result of the division.
+     */
+    public final NumberInterface divide(NumberInterface divisor){
+        checkInterrupted();
+        return divideInternal(divisor);
+    }
 
     /**
      * Adds this number to another, returning
@@ -37,7 +79,21 @@ public interface NumberInterface {
      * @param summand the summand
      * @return the result of the summation.
      */
-    NumberInterface add(NumberInterface summand);
+    protected abstract NumberInterface addInternal(NumberInterface summand);
+
+    /**
+     * Adds this number to another, returning
+     * a new number instance. Also, checks if the
+     * thread has been interrupted, and if so, throws
+     * an exception.
+     *
+     * @param summand the summand
+     * @return the result of the summation.
+     */
+    public final NumberInterface add(NumberInterface summand){
+        checkInterrupted();
+        return addInternal(summand);
+    }
 
     /**
      * Subtracts another number from this number,
@@ -46,7 +102,21 @@ public interface NumberInterface {
      * @param subtrahend the subtrahend.
      * @return the result of the subtraction.
      */
-    NumberInterface subtract(NumberInterface subtrahend);
+    protected abstract NumberInterface subtractInternal(NumberInterface subtrahend);
+
+    /**
+     * Subtracts another number from this number,
+     * a new number instance. Also, checks if the
+     * thread has been interrupted, and if so, throws
+     * an exception.
+     *
+     * @param subtrahend the subtrahend.
+     * @return the result of the subtraction.
+     */
+    public final NumberInterface subtract(NumberInterface subtrahend){
+        checkInterrupted();
+        return subtractInternal(subtrahend);
+    }
 
     /**
      * Returns a new instance of this number with
@@ -54,7 +124,21 @@ public interface NumberInterface {
      *
      * @return the new instance.
      */
-    NumberInterface negate();
+    protected abstract NumberInterface negateInternal();
+
+
+    /**
+     * Returns a new instance of this number with
+     * the sign flipped. Also, checks if the
+     * thread has been interrupted, and if so, throws
+     * an exception.
+     *
+     * @return the new instance.
+     */
+    public final NumberInterface negate(){
+        checkInterrupted();
+        return negateInternal();
+    }
 
     /**
      * Raises this number to an integer power.
@@ -62,7 +146,20 @@ public interface NumberInterface {
      * @param exponent the exponent to which to take the number.
      * @return the resulting value.
      */
-    NumberInterface intPow(int exponent);
+    protected abstract NumberInterface intPowInternal(int exponent);
+
+    /**
+     * Raises this number to an integer power. Also, checks if the
+     * thread has been interrupted, and if so, throws
+     * an exception.
+     *
+     * @param exponent the exponent to which to take the number.
+     * @return the resulting value.
+     */
+    public final NumberInterface intPow(int exponent){
+        checkInterrupted();
+        return intPowInternal(exponent);
+    }
 
     /**
      * Compares this number to another.
@@ -70,20 +167,78 @@ public interface NumberInterface {
      * @param number the number to compare to.
      * @return same as Integer.compare();
      */
-    int compareTo(NumberInterface number);
+    public abstract int compareTo(NumberInterface number);
 
     /**
      * Same as Math.signum().
      *
      * @return 1 if this number is positive, -1 if this number is negative, 0 if this number is 0.
      */
-    int signum();
+    public abstract int signum();
 
     /**
      * Returns the least integer greater than or equal to the number.
-     * @return the least integer >= the number, if int can hold the value.
+     *
+     * @return the least integer greater or equal to the number, if int can hold the value.
      */
-    int ceiling();
+    protected abstract NumberInterface ceilingInternal();
+
+    /**
+     * Returns the least integer greater than or equal to the number.
+     * Also, checks if the thread has been interrupted, and if so, throws
+     * an exception.
+     *
+     * @return the least integer bigger or equal to the number, if int can hold the value.
+     */
+    public final NumberInterface ceiling(){
+        checkInterrupted();
+        return ceilingInternal();
+    }
+
+    /**
+     * Return the greatest integer less than or equal to the number.
+     *
+     * @return the greatest integer smaller or equal the number, if int can hold the value.
+     */
+    protected abstract NumberInterface floorInternal();
+
+    /**
+     * Return the greatest integer less than or equal to the number.
+     * Also, checks if the thread has been interrupted, and if so, throws
+     * an exception.
+     *
+     * @return the greatest int smaller or equal to the number, if int can hold the value.
+     */
+    public final NumberInterface floor(){
+        checkInterrupted();
+        return floorInternal();
+    }
+
+    /**
+     * Returns the fractional part of the number.
+     *
+     * @return the fractional part of the number.
+     */
+    protected abstract NumberInterface fractionalPartInternal();
+
+    /**
+     * Returns the fractional part of the number.
+     * Also, checks if the thread has been interrupted,
+     * and if so, throws an exception.
+     * @return the fractional part of the number.
+     */
+    public final NumberInterface fractionalPart(){
+        checkInterrupted();
+        return fractionalPartInternal();
+    }
+
+    /**
+     * Returns the integer representation of this number, discarding any fractional part,
+     * if int can hold the value.
+     *
+     * @return the integer value of this number.
+     */
+    public abstract int intValue();
 
     /**
      * Promotes this class to another number class.
@@ -91,6 +246,19 @@ public interface NumberInterface {
      * @param toClass the class to promote to.
      * @return the resulting new instance.
      */
-    NumberInterface promoteTo(Class<? extends NumberInterface> toClass);
+    protected abstract NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass);
+
+    /**
+     * Promotes this class to another number class. Also, checks if the
+     * thread has been interrupted, and if so, throws
+     * an exception.
+     *
+     * @param toClass the class to promote to.
+     * @return the resulting new instance.
+     */
+    public final NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
+        checkInterrupted();
+        return promoteToInternal(toClass);
+    }
 
 }

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

@@ -7,20 +7,20 @@ import java.math.RoundingMode;
  * A number that uses a BigDecimal to store its value,
  * leading to infinite possible precision.
  */
-public class PreciseNumber implements NumberInterface {
+public class PreciseNumber extends NumberInterface {
 
     /**
      * The number one.
      */
-    static final PreciseNumber ONE = new PreciseNumber(BigDecimal.ONE);
+    public static final PreciseNumber ONE = new PreciseNumber(BigDecimal.ONE);
     /**
      * The number zero.
      */
-    static final PreciseNumber ZERO = new PreciseNumber(BigDecimal.ZERO);
+    public static final PreciseNumber ZERO = new PreciseNumber(BigDecimal.ZERO);
     /**
      * The number ten.
      */
-    static final PreciseNumber TEN = new PreciseNumber(BigDecimal.TEN);
+    public static final PreciseNumber TEN = new PreciseNumber(BigDecimal.TEN);
 
     /**
      * The value of the PreciseNumber.
@@ -52,27 +52,27 @@ public class PreciseNumber implements NumberInterface {
     }
 
     @Override
-    public NumberInterface multiply(NumberInterface multiplier) {
-        return new PreciseNumber(this.value.multiply(((PreciseNumber) multiplier).value));
+    public NumberInterface multiplyInternal(NumberInterface multiplier) {
+        return new PreciseNumber(this.value.multiply(((PreciseNumber) multiplier.number()).value));
     }
 
     @Override
-    public NumberInterface divide(NumberInterface divisor) {
-        return new PreciseNumber(value.divide(((PreciseNumber) divisor).value, this.getMaxPrecision(), RoundingMode.HALF_UP));
+    public NumberInterface divideInternal(NumberInterface divisor) {
+        return new PreciseNumber(value.divide(((PreciseNumber) divisor.number()).value, this.getMaxPrecision(), RoundingMode.HALF_UP));
     }
 
     @Override
-    public NumberInterface add(NumberInterface summand) {
-        return new PreciseNumber(value.add(((PreciseNumber) summand).value));
+    public NumberInterface addInternal(NumberInterface summand) {
+        return new PreciseNumber(value.add(((PreciseNumber) summand.number()).value));
     }
 
     @Override
-    public NumberInterface subtract(NumberInterface subtrahend) {
-        return new PreciseNumber(value.subtract(((PreciseNumber) subtrahend).value));
+    public NumberInterface subtractInternal(NumberInterface subtrahend) {
+        return new PreciseNumber(value.subtract(((PreciseNumber) subtrahend.number()).value));
     }
 
     @Override
-    public NumberInterface intPow(int exponent) {
+    public NumberInterface intPowInternal(int exponent) {
         if (exponent == 0) {
             return PreciseNumber.ONE;
         }
@@ -90,7 +90,7 @@ public class PreciseNumber implements NumberInterface {
 
     @Override
     public int compareTo(NumberInterface number) {
-        return value.compareTo(((PreciseNumber) number).value);
+        return value.compareTo(((PreciseNumber) number.number()).value);
     }
 
     @Override
@@ -99,17 +99,47 @@ public class PreciseNumber implements NumberInterface {
     }
 
     @Override
-    public int ceiling() {
-        return (int) Math.ceil(value.doubleValue());
+    public NumberInterface ceilingInternal() {
+        String str = value.toPlainString();
+        int decimalIndex = str.indexOf('.');
+        if (decimalIndex != -1) {
+            return this.floor().add(ONE);
+        }
+        return this;
     }
 
     @Override
-    public NumberInterface negate() {
+    public NumberInterface floorInternal() {
+        String str = value.toPlainString();
+        int decimalIndex = str.indexOf('.');
+        if (decimalIndex != -1) {
+            return new PreciseNumber(str.substring(0, decimalIndex));
+        }
+        return this;
+    }
+
+    @Override
+    public NumberInterface fractionalPartInternal() {
+        String str = value.toPlainString();
+        int decimalIndex = str.indexOf('.');
+        if (decimalIndex != -1) {
+            return new PreciseNumber(str.substring(decimalIndex + 1));
+        }
+        return ZERO;
+    }
+
+    @Override
+    public int intValue() {
+        return value.intValue();
+    }
+
+    @Override
+    public NumberInterface negateInternal() {
         return new PreciseNumber(value.negate());
     }
 
     @Override
-    public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
+    public NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass) {
         if (toClass == this.getClass()) {
             return this;
         }

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

@@ -0,0 +1,102 @@
+package org.nwapw.abacus.number;
+
+public class Variable extends NumberInterface{
+    public NumberInterface value;
+    public String variable;
+
+    public Variable(NumberInterface value,String variable){
+        this.value = value;
+        this.variable = variable;
+    }
+    public String getVariable(){
+        return variable;
+    }
+
+    @Override
+    public NumberInterface number(){
+        return value.number();
+    }
+
+    @Override
+    public Class<? extends NumberInterface> getClassVal(){
+        return value.getClassVal();
+    }
+
+    @Override
+    public int getMaxPrecision() {
+        return value.getMaxPrecision();
+    }
+
+    @Override
+    protected NumberInterface multiplyInternal(NumberInterface multiplier) {
+        value = value.promoteToInternal(multiplier.number().getClass());
+        return value.multiplyInternal(multiplier.number());
+    }
+
+    @Override
+    protected NumberInterface divideInternal(NumberInterface divisor) {
+        value = value.promoteToInternal(divisor.number().getClass());
+        return value.divideInternal(divisor.number());
+    }
+
+    @Override
+    protected NumberInterface addInternal(NumberInterface summand) {
+        value = value.promoteToInternal(summand.number().getClass());
+        return value.addInternal(summand.number());
+    }
+
+    @Override
+    protected NumberInterface subtractInternal(NumberInterface subtrahend) {
+        value = value.promoteToInternal(subtrahend.number().getClass());
+        return value.subtractInternal(subtrahend.number());
+    }
+
+    @Override
+    protected NumberInterface negateInternal() {
+        return value.negateInternal();
+    }
+
+    @Override
+    protected NumberInterface intPowInternal(int exponent) {
+        return value.intPowInternal(exponent);
+    }
+
+    @Override
+    public int compareTo(NumberInterface number) {
+        value = value.promoteToInternal(number.number().getClass());
+        return value.compareTo(number.number());
+    }
+
+    @Override
+    public int signum() {
+        return value.signum();
+    }
+
+    @Override
+    protected NumberInterface ceilingInternal() {
+        return value.ceilingInternal();
+    }
+
+    @Override
+    protected NumberInterface floorInternal() {
+        return value.floorInternal();
+    }
+
+    @Override
+    protected NumberInterface fractionalPartInternal() {
+        return value.fractionalPartInternal();
+    }
+
+    @Override
+    public int intValue() {
+        return value.intValue();
+    }
+
+    @Override
+    protected NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass) {
+        return value.promoteToInternal(toClass);
+    }
+    public String toString(){
+        return value.toString();
+    }
+}

src/main/java/org/nwapw/abacus/parsing/LexerTokenizer.java

@@ -36,6 +36,7 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
             register("[0-9]*(\\.[0-9]+)?", TokenType.NUM);
             register("\\(", TokenType.OPEN_PARENTH);
             register("\\)", TokenType.CLOSE_PARENTH);
+            register("[a-zA-Z]+",TokenType.VARIABLE);
         }};
     }
 

src/main/java/org/nwapw/abacus/parsing/ShuntingYardParser.java

@@ -63,7 +63,9 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             matchType = match.getType();
             if (matchType == TokenType.NUM) {
                 output.add(match);
-            } else if (matchType == TokenType.FUNCTION) {
+            }else if(matchType == TokenType.VARIABLE) {
+                output.add(match);
+            }else if (matchType == TokenType.FUNCTION) {
                 output.add(new Match<>("", TokenType.INTERNAL_FUNCTION_END));
                 tokenStack.push(match);
             } else if (matchType == TokenType.OP) {
@@ -77,8 +79,8 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                     continue;
                 }
 
-                if(tokenString.equals("-") && (previousType == null || previousType == TokenType.OP ||
-                        previousType == TokenType.OPEN_PARENTH)){
+                if (tokenString.equals("-") && (previousType == null || previousType == TokenType.OP ||
+                        previousType == TokenType.OPEN_PARENTH)) {
                     from.add(0, new Match<>("`", TokenType.OP));
                     continue;
                 }
@@ -144,6 +146,8 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             }
         } else if (matchType == TokenType.NUM) {
             return new NumberNode(abacus.numberFromString(match.getContent()));
+        } else if (matchType == TokenType.VARIABLE){
+            return new VariableNode(match.getContent());
         } else if (matchType == TokenType.FUNCTION) {
             String functionName = match.getContent();
             FunctionNode node = new FunctionNode(functionName);
@@ -162,8 +166,10 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
     @Override
     public TreeNode constructTree(List<Match<TokenType>> tokens) {
         tokens = intoPostfix(new ArrayList<>(tokens));
+        if(tokens == null) return null;
         Collections.reverse(tokens);
-        return constructRecursive(tokens);
+        TreeNode constructedTree = constructRecursive(tokens);
+        return tokens.size() == 0 ? constructedTree : null;
     }
 
     @Override

src/main/java/org/nwapw/abacus/plugin/NumberImplementation.java

@@ -0,0 +1,81 @@
+package org.nwapw.abacus.plugin;
+
+import org.nwapw.abacus.number.NumberInterface;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * A class that holds data about a number implementation.
+ */
+public abstract class NumberImplementation {
+
+    /**
+     * The list of paths through which this implementation can be promoted.
+     */
+    protected Map<Class<? extends NumberInterface>, Function<NumberInterface, NumberInterface>> promotionPaths;
+    /**
+     * The implementation class for this implementation.
+     */
+    private Class<? extends NumberInterface> implementation;
+    /**
+     * The priority of converting into this number implementation.
+     */
+    private int priority;
+
+    /**
+     * Creates a new number implementation with the given data.
+     *
+     * @param implementation the implementation class.
+     * @param priority       the priority, higher means more likely to be converted into.
+     */
+    public NumberImplementation(Class<? extends NumberInterface> implementation, int priority) {
+        this.implementation = implementation;
+        this.priority = priority;
+        promotionPaths = new HashMap<>();
+    }
+
+    /**
+     * Gets the list of all promotion paths this implementation can take.
+     *
+     * @return the map of documentation paths.
+     */
+    public final Map<Class<? extends NumberInterface>, Function<NumberInterface, NumberInterface>> getPromotionPaths() {
+        return promotionPaths;
+    }
+
+    /**
+     * Gets the implementation class used by this implementation.
+     *
+     * @return the implementation class.
+     */
+    public final Class<? extends NumberInterface> getImplementation() {
+        return implementation;
+    }
+
+    /**
+     * Gets the priority of this number implementation.
+     *
+     * @return the priority.
+     */
+    public final int getPriority() {
+        return priority;
+    }
+
+    /**
+     * Abstract function to create a new instance from a string.
+     *
+     * @param string the string to create a number from.
+     * @return the resulting number.
+     */
+    public abstract NumberInterface instanceForString(String string);
+
+    /**
+     * Get the instance of pi with the given implementation.
+     *
+     * @return pi
+     */
+    public abstract NumberInterface instanceForPi();
+
+}

src/main/java/org/nwapw/abacus/plugin/Plugin.java

@@ -17,18 +17,6 @@ import java.util.Set;
  */
 public abstract class Plugin {
 
-    /**
-     * A hash map of functions mapped to their string names.
-     */
-    private Map<String, Function> functions;
-    /**
-     * A hash map of operators mapped to their string names.
-     */
-    private Map<String, Operator> operators;
-    /**
-     * A hash map of operators mapped to their string names.
-     */
-    private Map<String, Class<? extends NumberInterface>> numbers;
     /**
      * The plugin manager in which to search for functions
      * not inside this package,
@@ -49,69 +37,9 @@ public abstract class Plugin {
      */
     public Plugin(PluginManager manager) {
         this.manager = manager;
-        functions = new HashMap<>();
-        operators = new HashMap<>();
-        numbers = new HashMap<>();
         enabled = false;
     }
 
-    /**
-     * Gets the list of functions provided by this plugin.
-     *
-     * @return the list of registered functions.
-     */
-    public final Set<String> providedFunctions() {
-        return functions.keySet();
-    }
-
-    /**
-     * Gets the list of functions provided by this plugin.
-     *
-     * @return the list of registered functions.
-     */
-    public final Set<String> providedOperators() {
-        return operators.keySet();
-    }
-
-    /**
-     * Gets the list of all numbers provided by this plugin.
-     *
-     * @return the list of registered numbers.
-     */
-    public final Set<String> providedNumbers() {
-        return numbers.keySet();
-    }
-
-    /**
-     * Gets a function under the given function name.
-     *
-     * @param functionName the name of the function to get
-     * @return the function, or null if this plugin doesn't provide it.
-     */
-    public final Function getFunction(String functionName) {
-        return functions.get(functionName);
-    }
-
-    /**
-     * Gets an operator under the given operator name.
-     *
-     * @param operatorName the name of the operator to get.
-     * @return the operator, or null if this plugin doesn't provide it.
-     */
-    public final Operator getOperator(String operatorName) {
-        return operators.get(operatorName);
-    }
-
-    /**
-     * Gets the class under the given name.
-     *
-     * @param numberName the name of the class.
-     * @return the class, or null if the plugin doesn't provide it.
-     */
-    public final Class<? extends NumberInterface> getNumber(String numberName) {
-        return numbers.get(numberName);
-    }
-
     /**
      * Enables the function, loading the necessary instances
      * of functions.
@@ -129,8 +57,6 @@ public abstract class Plugin {
     public final void disable() {
         if (!enabled) return;
         onDisable();
-        functions.clear();
-        operators.clear();
         enabled = false;
     }
 
@@ -142,7 +68,7 @@ public abstract class Plugin {
      * @param toRegister the function implementation.
      */
     protected final void registerFunction(String name, Function toRegister) {
-        functions.put(name, toRegister);
+        manager.registerFunction(name, toRegister);
     }
 
     /**
@@ -154,20 +80,18 @@ public abstract class Plugin {
      * @param operator the operator to register.
      */
     protected final void registerOperator(String name, Operator operator) {
-        operators.put(name, operator);
+        manager.registerOperator(name, operator);
     }
 
     /**
-     * To be used in load(). Registers a number class
-     * with the plugin internally, which makes it possible
-     * for the user to select it as an "implementation" for the
-     * number that they would like to use.
+     * To be used in load(). Registers a new number implementation with the plugin.
+     * This makes it accessible to the plugin manager.
      *
-     * @param name       the name to register it under.
-     * @param toRegister the class to register.
+     * @param name           the name of the implementation.
+     * @param implementation the actual implementation class to register.
      */
-    protected final void registerNumber(String name, Class<? extends NumberInterface> toRegister) {
-        numbers.put(name, toRegister);
+    protected final void registerNumberImplementation(String name, NumberImplementation implementation) {
+        manager.registerNumberImplementation(name, implementation);
     }
 
     /**
@@ -194,6 +118,31 @@ public abstract class Plugin {
         return manager.operatorFor(name);
     }
 
+    /**
+     * Searches the PluginManager for the given number implementation
+     * name. This can be used by the plugins internally in order to find
+     * implementations that they do not provide.
+     *
+     * @param name the name for which to search.
+     * @return the resulting number implementation, or null if none was found.
+     */
+    protected final NumberImplementation numberImplementationFor(String name) {
+        return manager.numberImplementationFor(name);
+    }
+
+    /**
+     * Searches the plugin manager for a Pi value for the given number implementation.
+     * This is done so that number implementations with various degrees of precision
+     * can provide their own pi values, without losing said precision by
+     * promoting NaiveNumbers.
+     *
+     * @param forClass the class to which to find the pi instance.
+     * @return the pi value for the given class.
+     */
+    protected final NumberInterface piFor(Class<? extends NumberInterface> forClass) {
+        return manager.piFor(forClass);
+    }
+
     /**
      * Abstract method to be overridden by plugin implementation, in which the plugins
      * are supposed to register the functions they provide and do any other

src/main/java/org/nwapw/abacus/plugin/PluginManager.java

@@ -23,32 +23,26 @@ public class PluginManager {
      */
     private Set<Plugin> plugins;
     /**
-     * List of functions that have been cached,
-     * that is, found in a plugin and returned.
+     * The map of functions registered by the plugins.
      */
-    private Map<String, Function> cachedFunctions;
+    private Map<String, Function> registeredFunctions;
     /**
-     * List of operators that have been cached,
-     * that is, found in a plugin and returned.
+     * The map of operators registered by the plugins
      */
-    private Map<String, Operator> cachedOperators;
+    private Map<String, Operator> registeredOperators;
     /**
-     * List of registered number implementations that have
-     * been cached, that is, found in a plugin and returned.
+     * The map of number implementations registered by the plugins.
      */
-    private Map<String, Class<? extends NumberInterface>> cachedNumbers;
+    private Map<String, NumberImplementation> registeredNumberImplementations;
     /**
-     * List of all functions loaded by the plugins.
+     * The list of number implementations that have been
+     * found by their implementation class.
      */
-    private Set<String> allFunctions;
+    private Map<Class<? extends NumberInterface>, NumberImplementation> cachedInterfaceImplementations;
     /**
-     * List of all operators loaded by the plugins.
+     * The pi values for each implementation class that have already been computer.
      */
-    private Set<String> allOperators;
-    /**
-     * List of all numbers loaded by the plugins.
-     */
-    private Set<String> allNumbers;
+    private Map<Class<? extends NumberInterface>, NumberInterface> cachedPi;
     /**
      * The list of plugin listeners attached to this instance.
      */
@@ -61,80 +55,110 @@ public class PluginManager {
 
     /**
      * Creates a new plugin manager.
+     *
+     * @param abacus the abacus instance.
      */
     public PluginManager(Abacus abacus) {
         this.abacus = abacus;
         loadedPluginClasses = new HashSet<>();
         plugins = new HashSet<>();
-        cachedFunctions = new HashMap<>();
-        cachedOperators = new HashMap<>();
-        cachedNumbers = new HashMap<>();
-        allFunctions = new HashSet<>();
-        allOperators = new HashSet<>();
-        allNumbers = new HashSet<>();
+        registeredFunctions = new HashMap<>();
+        registeredOperators = new HashMap<>();
+        registeredNumberImplementations = new HashMap<>();
+        cachedInterfaceImplementations = new HashMap<>();
+        cachedPi = new HashMap<>();
         listeners = new HashSet<>();
     }
 
     /**
-     * Searches the plugin list for a certain value, retrieving the Plugin's
-     * list of items of the type using the setFunction and getting the value
-     * of it is available via getFunction. If the value is contained
-     * in the cache, it returns the cached value instead.
-     *
-     * @param plugins     the plugin list to search.
-     * @param cache       the cache to use
-     * @param setFunction the function to retrieve a set of available T's from the plugin
-     * @param getFunction the function to get the T value under the given name
-     * @param name        the name to search for
-     * @param <T>         the type of element being search
-     * @return the retrieved element, or null if it was not found.
+     * Registers a function under the given name.
+     * @param name the name of the function.
+     * @param function the function to register.
      */
-    private static <T> T searchCached(Collection<Plugin> plugins, Map<String, T> cache,
-                                      java.util.function.Function<Plugin, Set<String>> setFunction,
-                                      java.util.function.BiFunction<Plugin, String, T> getFunction,
-                                      String name) {
-        if (cache.containsKey(name)) return cache.get(name);
+    public void registerFunction(String name, Function function){
+        registeredFunctions.put(name, function);
+    }
 
-        T loadedValue = null;
-        for (Plugin plugin : plugins) {
-            if (setFunction.apply(plugin).contains(name)) {
-                loadedValue = getFunction.apply(plugin, name);
+    /**
+     * Registers an operator under the given name.
+     * @param name the name of the operator.
+     * @param operator the operator to register.
+     */
+    public void registerOperator(String name, Operator operator){
+        registeredOperators.put(name, operator);
+    }
+
+    /**
+     * Registers a number implementation under the given name.
+     * @param name the name of the number implementation.
+     * @param implementation the number implementation to register.
+     */
+    public void registerNumberImplementation(String name, NumberImplementation implementation){
+        registeredNumberImplementations.put(name, implementation);
+    }
+
+    /**
+     * Gets the function registered under the given name.
+     * @param name the name of the function.
+     * @return the function, or null if it was not found.
+     */
+    public Function functionFor(String name){
+        return registeredFunctions.get(name);
+    }
+
+    /**
+     * Gets the operator registered under the given name.
+     * @param name the name of the operator.
+     * @return the operator, or null if it was not found.
+     */
+    public Operator operatorFor(String name){
+        return registeredOperators.get(name);
+    }
+
+    /**
+     * Gets the number implementation registered under the given name.
+     * @param name the name of the number implementation.
+     * @return the number implementation, or null if it was not found.
+     */
+    public NumberImplementation numberImplementationFor(String name){
+        return registeredNumberImplementations.get(name);
+    }
+
+    /**
+     * Gets the number implementation for the given implementation class.
+     *
+     * @param name the class for which to find the implementation.
+     * @return the implementation.
+     */
+    public NumberImplementation interfaceImplementationFor(Class<? extends NumberInterface> name) {
+        if (cachedInterfaceImplementations.containsKey(name)) return cachedInterfaceImplementations.get(name);
+        NumberImplementation toReturn = null;
+        for(String key : registeredNumberImplementations.keySet()){
+            NumberImplementation implementation = registeredNumberImplementations.get(key);
+            if(implementation.getImplementation() == name) {
+                toReturn = implementation;
                 break;
             }
         }
-
-        cache.put(name, loadedValue);
-        return loadedValue;
+        cachedInterfaceImplementations.put(name, toReturn);
+        return toReturn;
     }
 
     /**
-     * Gets a function under the given name.
+     * Gets the mathematical constant pi for the given implementation class.
      *
-     * @param name the name of the function
-     * @return the function under the given name.
+     * @param forClass the class for which to find pi.
+     * @return pi
      */
-    public Function functionFor(String name) {
-        return searchCached(plugins, cachedFunctions, Plugin::providedFunctions, Plugin::getFunction, name);
-    }
-
-    /**
-     * Gets an operator under the given name.
-     *
-     * @param name the name of the operator.
-     * @return the operator under the given name.
-     */
-    public Operator operatorFor(String name) {
-        return searchCached(plugins, cachedOperators, Plugin::providedOperators, Plugin::getOperator, name);
-    }
-
-    /**
-     * Gets a numer implementation under the given name.
-     *
-     * @param name the name of the implementation.
-     * @return the implementation class
-     */
-    public Class<? extends NumberInterface> numberFor(String name) {
-        return searchCached(plugins, cachedNumbers, Plugin::providedNumbers, Plugin::getNumber, name);
+    public NumberInterface piFor(Class<? extends NumberInterface> forClass) {
+        if (cachedPi.containsKey(forClass)) return cachedPi.get(forClass);
+        NumberImplementation implementation = interfaceImplementationFor(forClass);
+        NumberInterface generatedPi = null;
+        if (implementation != null) {
+            generatedPi = implementation.instanceForPi();
+        }
+        cachedPi.put(forClass, generatedPi);
+        return generatedPi;
     }
 
     /**
@@ -169,15 +193,9 @@ public class PluginManager {
     public void load() {
         Set<String> disabledPlugins = abacus.getConfiguration().getDisabledPlugins();
         for (Plugin plugin : plugins) {
-            if(disabledPlugins.contains(plugin.getClass().getName())) continue;
+            if (disabledPlugins.contains(plugin.getClass().getName())) continue;
             plugin.enable();
         }
-        for (Plugin plugin : plugins) {
-            if(disabledPlugins.contains(plugin.getClass().getName())) continue;
-            allFunctions.addAll(plugin.providedFunctions());
-            allOperators.addAll(plugin.providedOperators());
-            allNumbers.addAll(plugin.providedNumbers());
-        }
         listeners.forEach(e -> e.onLoad(this));
     }
 
@@ -188,15 +206,12 @@ public class PluginManager {
         listeners.forEach(e -> e.onUnload(this));
         Set<String> disabledPlugins = abacus.getConfiguration().getDisabledPlugins();
         for (Plugin plugin : plugins) {
-            if(disabledPlugins.contains(plugin.getClass().getName())) continue;
+            if (disabledPlugins.contains(plugin.getClass().getName())) continue;
             plugin.disable();
         }
-        cachedFunctions.clear();
-        cachedOperators.clear();
-        cachedNumbers.clear();
-        allFunctions.clear();
-        allOperators.clear();
-        allNumbers.clear();
+        cachedInterfaceImplementations.clear();
+        cachedPi.clear();
+        listeners.forEach(e -> e.onUnload(this));
     }
 
     /**
@@ -213,7 +228,7 @@ public class PluginManager {
      * @return the set of all functions that were loaded.
      */
     public Set<String> getAllFunctions() {
-        return allFunctions;
+        return registeredFunctions.keySet();
     }
 
     /**
@@ -222,16 +237,16 @@ public class PluginManager {
      * @return the set of all operators that were loaded.
      */
     public Set<String> getAllOperators() {
-        return allOperators;
+        return registeredOperators.keySet();
     }
 
     /**
-     * Gets all the number implementations loaded by the Plugin Manager
+     * Gets all the number implementations loaded by the Plugin Manager.
      *
-     * @return the set of all implementations that were loaded
+     * @return the set of all implementations that were loaded.
      */
-    public Set<String> getAllNumbers() {
-        return allNumbers;
+    public Set<String> getAllNumberImplementations() {
+        return registeredNumberImplementations.keySet();
     }
 
     /**
@@ -255,6 +270,7 @@ public class PluginManager {
     /**
      * Gets a list of all the plugin class files that have been
      * added to the plugin manager.
+     *
      * @return the list of all the added plugin classes.
      */
     public Set<Class<?>> getLoadedPluginClasses() {

src/main/java/org/nwapw/abacus/plugin/StandardPlugin.java

@@ -18,7 +18,10 @@ import java.util.function.BiFunction;
  */
 public class StandardPlugin extends Plugin {
 
-    private static HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> factorialLists = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
+    /**
+     * Stores objects of NumberInterface with integer values for reuse.
+     */
+    private final static HashMap<Class<? extends NumberInterface>, HashMap<Integer, NumberInterface>> integerValues = new HashMap<>();
 
     /**
      * The addition operator, +
@@ -50,6 +53,7 @@ public class StandardPlugin extends Plugin {
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
             return params[0].subtract(params[1]);
+
         }
     });
     /**
@@ -90,7 +94,7 @@ public class StandardPlugin extends Plugin {
     public static final Operator OP_DIVIDE = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1, new Function() {
         @Override
         protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 2;
+            return params.length == 2 && params[1].compareTo(NaiveNumber.ZERO.promoteTo(params[1].getClassVal())) != 0;
         }
 
         @Override
@@ -105,42 +109,30 @@ public class StandardPlugin extends Plugin {
         //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
         @Override
         protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1;
+            return params.length == 1
+                    && params[0].fractionalPart().compareTo(NaiveNumber.ZERO.promoteTo(params[0].getClassVal())) == 0
+                    && params[0].signum() >= 0;
         }
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
             if (params[0].signum() == 0) {
-                return (new NaiveNumber(1)).promoteTo(params[0].getClass());
+                return fromInt(params[0].getClassVal(), 1);
             }
             NumberInterface factorial = params[0];
             NumberInterface multiplier = params[0];
             //It is necessary to later prevent calls of factorial on anything but non-negative integers.
-            while ((multiplier = multiplier.subtract(NaiveNumber.ONE.promoteTo(multiplier.getClass()))).signum() == 1) {
+            while ((multiplier = multiplier.subtract(NaiveNumber.ONE.promoteTo(multiplier.getClassVal()))).signum() == 1) {
                 factorial = factorial.multiply(multiplier);
             }
             return factorial;
-                /*if(!storedList.containsKey(params[0].getClass())){
-                    storedList.put(params[0].getClass(), new ArrayList<NumberInterface>());
-                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
-                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
+                /*if(!storedList.containsKey(params[0].getClassVal())){
+                    storedList.put(params[0].getClassVal(), new ArrayList<NumberInterface>());
+                    storedList.get(params[0].getClassVal()).add(NaiveNumber.ONE.promoteTo(params[0].getClassVal()));
+                    storedList.get(params[0].getClassVal()).add(NaiveNumber.ONE.promoteTo(params[0].getClassVal()));
                 }*/
         }
     });
-    /**
-     * The caret / pow operator, ^
-     */
-    public static final Operator OP_CARET = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2, new Function() {
-        @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 2;
-        }
-
-        @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return FUNCTION_EXP.apply(FUNCTION_LN.apply(params[0]).multiply(params[1]));
-        }
-    });
     /**
      * The absolute value function, abs(-3) = 3
      */
@@ -152,50 +144,7 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
-            return params[0].multiply((new NaiveNumber(params[0].signum())).promoteTo(params[0].getClass()));
-        }
-    };
-    /**
-     * The exponential function, exp(1) = e^1 = 2.71...
-     */
-    public static final Function FUNCTION_EXP = new Function() {
-        @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1;
-        }
-
-        @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            NumberInterface maxError = getMaxError(params[0]);
-            int n = 0;
-            if(params[0].signum() <= 0){
-                NumberInterface currentTerm = NaiveNumber.ONE.promoteTo(params[0].getClass()), sum = currentTerm;
-                while(FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0){
-                    n++;
-                    currentTerm = currentTerm.multiply(params[0]).divide((new NaiveNumber(n)).promoteTo(params[0].getClass()));
-                    sum = sum.add(currentTerm);
-                }
-                return sum;
-            }
-            else{
-                //We need n such that x^(n+1) * 3^ceil(x) <= maxError * (n+1)!.
-                //right and left refer to lhs and rhs in the above inequality.
-                NumberInterface sum = NaiveNumber.ONE.promoteTo(params[0].getClass());
-                NumberInterface nextNumerator = params[0];
-                NumberInterface left = params[0].multiply((new NaiveNumber(3)).promoteTo(params[0].getClass()).intPow(params[0].ceiling())), right = maxError;
-                do{
-                    sum = sum.add(nextNumerator.divide(factorial(params[0].getClass(), n+1)));
-                    n++;
-                    nextNumerator = nextNumerator.multiply(params[0]);
-                    left = left.multiply(params[0]);
-                    NumberInterface nextN = (new NaiveNumber(n+1)).promoteTo(params[0].getClass());
-                    right = right.multiply(nextN);
-                    //System.out.println(left + ", " + right);
-                }
-                while(left.compareTo(right) > 0);
-                //System.out.println(n+1);
-                return sum;
-            }
+            return params[0].multiply((new NaiveNumber(params[0].signum())).promoteTo(params[0].getClassVal()));
         }
     };
     /**
@@ -204,31 +153,31 @@ public class StandardPlugin extends Plugin {
     public static final Function FUNCTION_LN = new Function() {
         @Override
         protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1;
+            return params.length == 1 && params[0].compareTo(NaiveNumber.ZERO.promoteTo(params[0].getClassVal())) > 0;
         }
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
             NumberInterface param = params[0];
             int powersOf2 = 0;
-            while (FUNCTION_ABS.apply(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass()))).compareTo((new NaiveNumber(0.1)).promoteTo(param.getClass())) >= 0) {
-                if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() == 1) {
-                    param = param.divide(new NaiveNumber(2).promoteTo(param.getClass()));
+            while (FUNCTION_ABS.apply(param.subtract(NaiveNumber.ONE.promoteTo(param.getClassVal()))).compareTo(new NaiveNumber(0.1).promoteTo(param.getClassVal())) >= 0) {
+                if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClassVal())).signum() == 1) {
+                    param = param.divide(fromInt(param.getClassVal(), 2));
                     powersOf2++;
-                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClassVal())).signum() != 1) {
                         break;
                         //No infinite loop for you.
                     }
                 } else {
-                    param = param.multiply(new NaiveNumber(2).promoteTo(param.getClass()));
+                    param = param.multiply(fromInt(param.getClassVal(), 2));
                     powersOf2--;
-                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != -1) {
+                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClassVal())).signum() != -1) {
                         break;
                         //No infinite loop for you.
                     }
                 }
             }
-            return getLog2(param).multiply((new NaiveNumber(powersOf2)).promoteTo(param.getClass())).add(getLogPartialSum(param));
+            return getLog2(param).multiply((new NaiveNumber(powersOf2)).promoteTo(param.getClassVal())).add(getLogPartialSum(param));
         }
 
         /**
@@ -238,14 +187,15 @@ public class StandardPlugin extends Plugin {
          * @return the partial sum.
          */
         private NumberInterface getLogPartialSum(NumberInterface x) {
+
             NumberInterface maxError = getMaxError(x);
-            x = x.subtract(NaiveNumber.ONE.promoteTo(x.getClass())); //Terms used are for log(x+1).
+            x = x.subtract(NaiveNumber.ONE.promoteTo(x.getClassVal())); //Terms used are for log(x+1).
             NumberInterface currentNumerator = x, currentTerm = x, sum = x;
             int n = 1;
             while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0) {
                 n++;
                 currentNumerator = currentNumerator.multiply(x).negate();
-                currentTerm = currentNumerator.divide(new NaiveNumber(n).promoteTo(x.getClass()));
+                currentTerm = currentNumerator.divide(new NaiveNumber(n).promoteTo(x.getClassVal()));
                 sum = sum.add(currentTerm);
             }
             return sum;
@@ -258,18 +208,18 @@ public class StandardPlugin extends Plugin {
          */
         private NumberInterface getLog2(NumberInterface number) {
             NumberInterface maxError = getMaxError(number);
-            //NumberInterface errorBound = (new NaiveNumber(1)).promoteTo(number.getClass());
+            //NumberInterface errorBound = fromInt(number.getClassVal(), 1);
             //We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
             //In the following, a=1/3^n, b=1/4^n, c = 1/n.
             //a is also an error bound.
-            NumberInterface a = (new NaiveNumber(1)).promoteTo(number.getClass()), b = a, c = a;
-            NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClass());
+            NumberInterface a = fromInt(number.getClassVal(), 1), b = a, c = a;
+            NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClassVal());
             int n = 0;
             while (a.compareTo(maxError) >= 1) {
                 n++;
-                a = a.divide((new NaiveNumber(3)).promoteTo(number.getClass()));
-                b = b.divide((new NaiveNumber(4)).promoteTo(number.getClass()));
-                c = NaiveNumber.ONE.promoteTo(number.getClass()).divide((new NaiveNumber(n)).promoteTo(number.getClass()));
+                a = a.divide(fromInt(number.getClassVal(), 3));
+                b = b.divide(fromInt(number.getClassVal(), 4));
+                c = NaiveNumber.ONE.promoteTo(number.getClassVal()).divide((new NaiveNumber(n)).promoteTo(number.getClassVal()));
                 sum = sum.add(a.add(b).multiply(c));
             }
             return sum;
@@ -286,7 +236,215 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
-            return OP_CARET.getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
+            return OP_CARET.getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClassVal())));
+        }
+    };
+    /**
+     * The implementation for double-based naive numbers.
+     */
+    public static final NumberImplementation IMPLEMENTATION_NAIVE = new NumberImplementation(NaiveNumber.class, 0) {
+        @Override
+        public NumberInterface instanceForString(String string) {
+            return new NaiveNumber(string);
+        }
+
+        @Override
+        public NumberInterface instanceForPi() {
+            return new NaiveNumber(Math.PI);
+        }
+    };
+    /**
+     * The implementation for the infinite-precision BigDecimal.
+     */
+    public static final NumberImplementation IMPLEMENTATION_PRECISE = new NumberImplementation(PreciseNumber.class, 0) {
+        @Override
+        public NumberInterface instanceForString(String string) {
+            return new PreciseNumber(string);
+        }
+
+        @Override
+        public NumberInterface instanceForPi() {
+            NumberInterface C = FUNCTION_SQRT.apply(new PreciseNumber("10005")).multiply(new PreciseNumber("426880"));
+            NumberInterface M = PreciseNumber.ONE;
+            NumberInterface L = new PreciseNumber("13591409");
+            NumberInterface X = M;
+            NumberInterface sum = L;
+            int termsNeeded = C.getMaxPrecision() / 13 + 1;
+
+            NumberInterface lSummand = new PreciseNumber("545140134");
+            NumberInterface xMultiplier = new PreciseNumber("262537412")
+                    .multiply(new PreciseNumber("1000000000"))
+                    .add(new PreciseNumber("640768000"))
+                    .negate();
+            for (int i = 0; i < termsNeeded; i++) {
+                M = M
+                        .multiply(new NaiveNumber(12 * i + 2).promoteTo(PreciseNumber.class))
+                        .multiply(new NaiveNumber(12 * i + 6).promoteTo(PreciseNumber.class))
+                        .multiply(new NaiveNumber(12 * i + 10).promoteTo(PreciseNumber.class))
+                        .divide(new NaiveNumber(Math.pow(i + 1, 3)).promoteTo(PreciseNumber.class));
+                L = L.add(lSummand);
+                X = X.multiply(xMultiplier);
+                sum = sum.add(M.multiply(L).divide(X));
+            }
+            return C.divide(sum);
+        }
+    };
+    private static final HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> FACTORIAL_LISTS = new HashMap<>();
+    /**
+     * The exponential function, exp(1) = e^1 = 2.71...
+     */
+    public static final Function FUNCTION_EXP = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface maxError = getMaxError(params[0]);
+            int n = 0;
+            if (params[0].signum() <= 0) {
+                NumberInterface currentTerm = NaiveNumber.ONE.promoteTo(params[0].getClassVal()), sum = currentTerm;
+                while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0) {
+                    n++;
+                    currentTerm = currentTerm.multiply(params[0]).divide((new NaiveNumber(n)).promoteTo(params[0].getClassVal()));
+                    sum = sum.add(currentTerm);
+                }
+                return sum;
+            } else {
+                //We need n such that x^(n+1) * 3^ceil(x) <= maxError * (n+1)!.
+                //right and left refer to lhs and rhs in the above inequality.
+                NumberInterface sum = NaiveNumber.ONE.promoteTo(params[0].getClassVal());
+                NumberInterface nextNumerator = params[0];
+                NumberInterface left = params[0].multiply(fromInt(params[0].getClassVal(), 3).intPow(params[0].ceiling().intValue())), right = maxError;
+                do {
+                    sum = sum.add(nextNumerator.divide(factorial(params[0].getClassVal(), n + 1)));
+                    n++;
+                    nextNumerator = nextNumerator.multiply(params[0]);
+                    left = left.multiply(params[0]);
+                    NumberInterface nextN = (new NaiveNumber(n + 1)).promoteTo(params[0].getClassVal());
+                    right = right.multiply(nextN);
+                    //System.out.println(left + ", " + right);
+                }
+                while (left.compareTo(right) > 0);
+                //System.out.println(n+1);
+                return sum;
+            }
+        }
+    };
+    /**
+     * The caret / pow operator, ^
+     */
+    public static final Operator OP_CARET = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 2
+                    && !(params[0].compareTo(NaiveNumber.ZERO.promoteTo(params[0].getClassVal())) == 0
+                    && params[1].compareTo(NaiveNumber.ZERO.promoteTo(params[1].getClassVal())) == 0);
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            if (params[0].compareTo(NaiveNumber.ZERO.promoteTo(params[0].getClassVal())) == 0)
+                return NaiveNumber.ZERO.promoteTo(params[0].getClassVal());
+            else if (params[1].compareTo(NaiveNumber.ZERO.promoteTo(params[0].getClassVal())) == 0)
+                return NaiveNumber.ONE.promoteTo(params[1].getClassVal());
+            return FUNCTION_EXP.apply(FUNCTION_LN.apply(FUNCTION_ABS.apply(params[0])).multiply(params[1]));
+        }
+    });
+    /**
+     * The sine function (the argument is interpreted in radians).
+     */
+    public final Function functionSin = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface pi = piFor(params[0].getClassVal());
+            NumberInterface twoPi = pi.multiply(fromInt(pi.getClassVal(), 2));
+            NumberInterface theta = getSmallAngle(params[0], pi);
+            //System.out.println(theta);
+            if (theta.compareTo(pi.multiply(new NaiveNumber(1.5).promoteTo(twoPi.getClassVal()))) >= 0) {
+                theta = theta.subtract(twoPi);
+            } else if (theta.compareTo(pi.divide(fromInt(pi.getClassVal(), 2))) > 0) {
+                theta = pi.subtract(theta);
+            }
+            //System.out.println(theta);
+            return sinTaylor(theta);
+        }
+    };
+    /**
+     * The cosine function (the argument is in radians).
+     */
+    public final Function functionCos = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return functionSin.apply(piFor(params[0].getClassVal()).divide(fromInt(params[0].getClassVal(), 2))
+                    .subtract(params[0]));
+        }
+    };
+    /**
+     * The tangent function (the argument is in radians).
+     */
+    public final Function functionTan = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return functionSin.apply(params[0]).divide(functionCos.apply(params[0]));
+        }
+    };
+    /**
+     * The secant function (the argument is in radians).
+     */
+    public final Function functionSec = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return NaiveNumber.ONE.promoteTo(params[0].getClassVal()).divide(functionCos.apply(params[0]));
+        }
+    };
+    /**
+     * The cosecant function (the argument is in radians).
+     */
+    public final Function functionCsc = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return NaiveNumber.ONE.promoteTo(params[0].getClassVal()).divide(functionSin.apply(params[0]));
+        }
+    };
+    /**
+     * The cotangent function (the argument is in radians).
+     */
+    public final Function functionCot = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return functionCos.apply(params[0]).divide(functionSin.apply(params[0]));
         }
     };
 
@@ -303,7 +461,7 @@ public class StandardPlugin extends Plugin {
      * @return the value of the partial sum that has the same class as x.
      */
     private static NumberInterface sumSeries(NumberInterface x, BiFunction<Integer, NumberInterface, NumberInterface> nthTermFunction, int n) {
-        NumberInterface sum = NaiveNumber.ZERO.promoteTo(x.getClass());
+        NumberInterface sum = NaiveNumber.ZERO.promoteTo(x.getClassVal());
         for (int i = 0; i <= n; i++) {
             sum = sum.add(nthTermFunction.apply(i, x));
         }
@@ -317,13 +475,87 @@ public class StandardPlugin extends Plugin {
      * @return the maximum error.
      */
     private static NumberInterface getMaxError(NumberInterface number) {
-        return (new NaiveNumber(10)).promoteTo(number.getClass()).intPow(-number.getMaxPrecision());
+        return fromInt(number.getClassVal(), 10).intPow(-number.getMaxPrecision());
+    }
+
+    /**
+     * A factorial function that uses memoization for each number class; it efficiently
+     * computes factorials of non-negative integers.
+     *
+     * @param numberClass type of number to return.
+     * @param n           non-negative integer.
+     * @return a number of numClass with value n factorial.
+     */
+    public static NumberInterface factorial(Class<? extends NumberInterface> numberClass, int n) {
+        if (!FACTORIAL_LISTS.containsKey(numberClass)) {
+            FACTORIAL_LISTS.put(numberClass, new ArrayList<>());
+            FACTORIAL_LISTS.get(numberClass).add(NaiveNumber.ONE.promoteTo(numberClass));
+            FACTORIAL_LISTS.get(numberClass).add(NaiveNumber.ONE.promoteTo(numberClass));
+        }
+        ArrayList<NumberInterface> list = FACTORIAL_LISTS.get(numberClass);
+        if (n >= list.size()) {
+            while (list.size() < n + 16) {
+                list.add(list.get(list.size() - 1).multiply(new NaiveNumber(list.size()).promoteTo(numberClass)));
+            }
+        }
+        return list.get(n);
+    }
+
+    /**
+     * Returns the value of the Taylor series for sin (centered at 0) at x.
+     *
+     * @param x where the series is evaluated.
+     * @return the value of the series
+     */
+    private static NumberInterface sinTaylor(NumberInterface x) {
+        NumberInterface power = x, multiplier = x.multiply(x).negate(), currentTerm = x, sum = x;
+        NumberInterface maxError = getMaxError(x);
+        int n = 1;
+        do {
+            n += 2;
+            power = power.multiply(multiplier);
+            currentTerm = power.divide(factorial(x.getClassVal(), n));
+            sum = sum.add(currentTerm);
+        } while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0);
+        return sum;
+    }
+
+    /**
+     * Returns an equivalent angle in the interval [0, 2pi)
+     *
+     * @param phi an angle (in radians).
+     * @return theta in [0, 2pi) that differs from phi by a multiple of 2pi.
+     */
+    private static NumberInterface getSmallAngle(NumberInterface phi, NumberInterface pi) {
+        NumberInterface twoPi = pi.multiply(new NaiveNumber("2").promoteTo(phi.getClassVal()));
+        NumberInterface theta = FUNCTION_ABS.apply(phi).subtract(twoPi
+                .multiply(FUNCTION_ABS.apply(phi).divide(twoPi).floor())); //Now theta is in [0, 2pi).
+        if (phi.signum() < 0) {
+            theta = twoPi.subtract(theta);
+        }
+        return theta;
+    }
+
+    /**
+     * Returns a number of class numType with value n.
+     * @param numType class of number to return.
+     * @param n value of returned number.
+     * @return numClass instance with value n.
+     */
+    private static NumberInterface fromInt(Class<? extends NumberInterface> numType, int n){
+        if(!integerValues.containsKey(numType)){
+            integerValues.put(numType, new HashMap<>());
+        }
+        if(!integerValues.get(numType).containsKey(n)){
+            integerValues.get(numType).put(n, new NaiveNumber(n).promoteTo(numType));
+        }
+        return integerValues.get(numType).get(n);
     }
 
     @Override
     public void onEnable() {
-        registerNumber("naive", NaiveNumber.class);
-        registerNumber("precise", PreciseNumber.class);
+        registerNumberImplementation("naive", IMPLEMENTATION_NAIVE);
+        registerNumberImplementation("precise", IMPLEMENTATION_PRECISE);
 
         registerOperator("+", OP_ADD);
         registerOperator("-", OP_SUBTRACT);
@@ -337,26 +569,16 @@ public class StandardPlugin extends Plugin {
         registerFunction("exp", FUNCTION_EXP);
         registerFunction("ln", FUNCTION_LN);
         registerFunction("sqrt", FUNCTION_SQRT);
+        registerFunction("sin", functionSin);
+        registerFunction("cos", functionCos);
+        registerFunction("tan", functionTan);
+        registerFunction("sec", functionSec);
+        registerFunction("csc", functionCsc);
+        registerFunction("cot", functionCot);
     }
 
     @Override
     public void onDisable() {
 
     }
-
-    public static NumberInterface factorial(Class<? extends NumberInterface> numberClass, int n){
-        if(!factorialLists.containsKey(numberClass)){
-            factorialLists.put(numberClass, new ArrayList<>());
-            factorialLists.get(numberClass).add(NaiveNumber.ONE.promoteTo(numberClass));
-            factorialLists.get(numberClass).add(NaiveNumber.ONE.promoteTo(numberClass));
-        }
-        ArrayList<NumberInterface> list = factorialLists.get(numberClass);
-        if(n >= list.size()){
-            while(list.size() < n + 16){
-                list.add(list.get(list.size()-1).multiply(new NaiveNumber(list.size()).promoteTo(numberClass)));
-            }
-        }
-        return list.get(n);
-    }
-
 }

src/main/java/org/nwapw/abacus/plugin/VariablePlugin.java

@@ -0,0 +1,52 @@
+package org.nwapw.abacus.plugin;
+
+import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
+import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.number.Variable;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+
+public class VariablePlugin extends Plugin {
+    private HashMap<String,NumberInterface> variableMap;
+    public final Operator OP_EQUALS = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, -1, new Function() {
+        //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 2;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            //System.out.println((char)Double.parseDouble(params[1].toString()));
+            //System.out.println(params[0].toString());
+            if (params[0] instanceof Variable){
+                variableMap.put(((Variable) params[0]).getVariable(), params[1]);
+            }
+            return params[1];
+        }
+    });
+    public NumberInterface getValue(String variable){
+        return variableMap.get(variable);
+    }
+    public VariablePlugin(PluginManager manager) {
+        super(manager);
+        //variables = new ArrayList<>();
+        variableMap=new HashMap<>();
+    }
+
+
+    @Override
+    public void onEnable(){
+        //variables = new ArrayList<>();
+        variableMap=new HashMap<>();
+        registerOperator("=",OP_EQUALS);
+    }
+    @Override
+    public void onDisable(){
+
+    }
+};

src/main/java/org/nwapw/abacus/tree/NumberReducer.java

@@ -3,6 +3,7 @@ package org.nwapw.abacus.tree;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.function.Function;
 import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.number.Variable;
 
 /**
  * A reducer implementation that turns a tree into a single number.
@@ -47,6 +48,8 @@ public class NumberReducer implements Reducer<NumberInterface> {
             Function function = abacus.getPluginManager().functionFor(((FunctionNode) node).getFunction());
             if (function == null) return null;
             return function.apply(convertedChildren);
+        } else if (node instanceof VariableNode){
+            return (NumberInterface)new Variable(abacus.getVar(((VariableNode)node).getVariable()),((VariableNode)node).getVariable());
         }
         return null;
     }

src/main/java/org/nwapw/abacus/tree/TokenType.java

@@ -7,7 +7,7 @@ package org.nwapw.abacus.tree;
 public enum TokenType {
 
     INTERNAL_FUNCTION_END(-1),
-    ANY(0), WHITESPACE(1), COMMA(2), OP(3), NUM(4), FUNCTION(5), OPEN_PARENTH(6), CLOSE_PARENTH(7);
+    ANY(0), WHITESPACE(1), COMMA(2), OP(3), NUM(4), VARIABLE(5), FUNCTION(6), OPEN_PARENTH(7), CLOSE_PARENTH(8);
 
     /**
      * The priority by which this token gets sorted.

src/main/java/org/nwapw/abacus/tree/VariableNode.java

@@ -0,0 +1,24 @@
+package org.nwapw.abacus.tree;
+
+import org.nwapw.abacus.number.NumberInterface;
+
+public class VariableNode extends TreeNode{
+    private String variable;
+    public VariableNode() {
+        variable = null;
+    }
+    public VariableNode(String name){
+        this.variable = name;
+    }
+    public String getVariable() {
+        return variable;
+    }
+    @Override
+    public <T> T reduce(Reducer<T> reducer) {
+        return reducer.reduceNode(this);
+    }
+    @Override
+    public String toString() {
+        return variable;
+    }
+}

src/main/java/org/nwapw/abacus/window/Window.java

@@ -250,6 +250,6 @@ public class Window extends JFrame {
     @Override
     public void setVisible(boolean b) {
         super.setVisible(b);
-        if(b) inputField.requestFocusInWindow();
+        if (b) inputField.requestFocusInWindow();
     }
 }

src/main/resources/abacus.fxml

@@ -2,14 +2,10 @@
 
 <?import javafx.geometry.Insets?>
 <?import javafx.scene.control.*?>
-<?import javafx.scene.layout.BorderPane?>
-<?import javafx.scene.layout.VBox?>
+<?import javafx.scene.layout.*?>
 <?import javafx.scene.text.Text?>
-<?import javafx.scene.layout.HBox?>
-<?import javafx.scene.layout.GridPane?>
-<?import javafx.scene.layout.FlowPane?>
-<BorderPane xmlns="http://javafx.com/javafx"
-            xmlns:fx="http://javafx.com/fxml"
+<BorderPane xmlns:fx="http://javafx.com/fxml"
+            xmlns="http://javafx.com/javafx"
             fx:controller="org.nwapw.abacus.fx.AbacusController">
     <center>
         <TabPane fx:id="coreTabPane">
@@ -38,25 +34,88 @@
                             <TextField fx:id="inputField" onAction="#performCalculation"/>
                             <Button fx:id="inputButton" text="Calculate" maxWidth="Infinity"
                                     onAction="#performCalculation"/>
+                            <Button fx:id="stopButton" text="Stop" maxWidth="Infinity"
+                                    onAction="#performStop" disable="true"/>
                         </VBox>
                     </bottom>
                 </BorderPane>
             </Tab>
             <Tab fx:id="settingsTab" text="Settings" closable="false">
                 <GridPane hgap="10" vgap="10">
-                    <padding><Insets left="10" right="10" top="10" bottom="10"/></padding>
+                    <padding>
+                        <Insets left="10" right="10" top="10" bottom="10"/>
+                    </padding>
                     <Label text="Number Implementation" GridPane.columnIndex="0" GridPane.rowIndex="0"/>
                     <ComboBox fx:id="numberImplementationBox" GridPane.columnIndex="1" GridPane.rowIndex="0"/>
                     <ListView fx:id="enabledPluginView"
                               GridPane.rowIndex="1" GridPane.columnIndex="0"
                               GridPane.columnSpan="2" maxHeight="100"/>
-                    <FlowPane GridPane.columnIndex="0" GridPane.columnSpan="2" GridPane.rowIndex="2" hgap="10" vgap="10">
+                    <Text GridPane.columnIndex="0" GridPane.rowIndex="2" text="Computation Limit"/>
+                    <TextField fx:id="computationLimitField" GridPane.columnIndex="1" GridPane.rowIndex="2"/>
+                    <FlowPane GridPane.columnIndex="0" GridPane.columnSpan="2" GridPane.rowIndex="3" hgap="10"
+                              vgap="10">
                         <Button text="Apply" onAction="#performSave"/>
                         <Button text="Reload Plugins" onAction="#performReload"/>
                         <Button text="Apply and Reload" onAction="#performSaveAndReload"/>
                     </FlowPane>
                 </GridPane>
             </Tab>
+            <Tab fx:id="macroTab" text="Macros" closable="false">
+                <BorderPane>
+                    <padding>
+                        <Insets top="10" bottom="10" left="10" right="10"/>
+                    </padding>
+                    <center>
+                        <BorderPane>
+                            <center>
+                                <ScrollPane hbarPolicy="NEVER" vbarPolicy="NEVER" prefWidth="50" fitToWidth="true">
+                                        <SplitPane prefHeight="Infinity" >
+                                            <BorderPane prefHeight="Infinity">
+                                                <center>
+                                                    <TextArea fx:id="macroField" wrapText="false" prefHeight="Infinity"/>
+                                                </center>
+                                            </BorderPane>
+                                            <BorderPane prefHeight="Infinity">
+                                                <center>
+                                                    <TextArea fx:id="macroOutputField" wrapText="false" text="aaa&#xA;aaaaa" editable="false" prefHeight="Infinity"/>
+                                                </center>
+                                            </BorderPane>
+                                        </SplitPane>
+                                </ScrollPane>
+
+                            </center>
+                        </BorderPane>
+                    </center>
+                    <bottom>
+                        <VBox>
+
+                            <Button fx:id="inputButtonMacro" text="Calculate"
+                                    onAction="#macroCalculation" maxWidth="Infinity"/>
+                            <Button fx:id="stopButtonMacro" text="Stop" onAction="#performStop" maxWidth="Infinity"/>
+                        </VBox>
+                    </bottom>
+                </BorderPane>
+                <!--
+                <GridPane>
+                    <padding>
+                        <Insets top="10" bottom="10" left="10" right="10"/>
+                    </padding>
+                    <columnConstraints>
+                        <ColumnConstraints percentWidth="100.0"/>
+                    </columnConstraints>
+                    <rowConstraints>
+                        <RowConstraints percentHeight="85.0"/>
+                        <RowConstraints/>
+                        <RowConstraints/>
+                    </rowConstraints>
+                    <TextArea fx:id="macroField" GridPane.columnIndex="0" GridPane.rowIndex="0"/>
+                    <Button fx:id="inputButtonMacro" text="Calculate" maxWidth="Infinity"
+                            onAction="#macroCalculation" GridPane.columnIndex="0" GridPane.rowIndex="1"/>
+                    <Button fx:id="stopButtonMacro" text="Stop" onAction="#performStop" maxWidth="Infinity"
+                            disable="true" GridPane.columnIndex="0" GridPane.rowIndex="2"/>
+                </GridPane>
+                -->
+            </Tab>
         </TabPane>
     </center>
 

src/test/java/org/nwapw/abacus/tests/CalculationTests.java

@@ -0,0 +1,104 @@
+package org.nwapw.abacus.tests;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.config.Configuration;
+import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.plugin.StandardPlugin;
+import org.nwapw.abacus.tree.TreeNode;
+
+public class CalculationTests {
+
+    private static Abacus abacus = new Abacus(new Configuration(0, "precise", new String[]{}),null);
+
+    @BeforeClass
+    public static void prepareTests(){
+        abacus.getPluginManager().addInstantiated(new StandardPlugin(abacus.getPluginManager()));
+        abacus.getPluginManager().load();
+    }
+
+    private void testOutput(String input, String parseOutput, String output){
+        TreeNode parsedTree = abacus.parseString(input);
+        Assert.assertNotNull(parsedTree);
+        Assert.assertEquals(parsedTree.toString(), parseOutput);
+        NumberInterface result = abacus.evaluateTree(parsedTree);
+        Assert.assertNotNull(result);
+        Assert.assertTrue(result.toString().startsWith(output));
+    }
+
+    private void testEvalError(String input, String parseOutput){
+        TreeNode parsedTree = abacus.parseString(input);
+        Assert.assertNotNull(parsedTree);
+        Assert.assertEquals(parsedTree.toString(), parseOutput);
+        Assert.assertNull(abacus.evaluateTree(parsedTree));
+    }
+
+    @Test
+    public void testAddition(){
+        testOutput("9.5+10", "(9.5+10)", "19.5");
+    }
+
+    @Test
+    public void testSubtraction(){
+        testOutput("9.5-10", "(9.5-10)", "-0.5");
+    }
+
+    @Test
+    public void testMultiplication(){
+        testOutput("9.5*10", "(9.5*10)", "95");
+    }
+
+    @Test
+    public void testDivision(){
+        testOutput("9.5/2", "(9.5/2)", "4.75");
+    }
+
+    @Test
+    public void testNegation(){
+        testOutput("-9.5", "(9.5)`", "-9.5");
+    }
+
+    @Test
+    public void testFactorial(){
+        testOutput("7!", "(7)!", "5040");
+    }
+
+    @Test
+    public void testAbs(){
+        testOutput("abs(-1)", "abs((1)`)", "1");
+        testOutput("abs(1)", "abs(1)", "1");
+    }
+
+    @Test
+    public void testLn(){
+        testEvalError("ln(-1)", "ln((1)`)");
+        testOutput("ln2", "ln(2)", "0.6931471805599453094172321214581765680755");
+    }
+
+    @Test
+    public void testSqrt(){
+        testOutput("sqrt0", "sqrt(0)", "0");
+        testOutput("sqrt4", "sqrt(4)", "2");
+        testOutput("sqrt2", "sqrt(2)", "1.4142135623730950488016887242096980785696");
+    }
+
+    @Test
+    public void testExp(){
+        testOutput("exp0", "exp(0)", "1");
+        testOutput("exp1", "exp(1)", "2.718281828459045235360287471352662497757247");
+        testOutput("exp300", "exp(300)", "19424263952412559365842088360176992193662086");
+        testOutput("exp300", "exp(300)", "19424263952412559365842088360176992193662086");
+    }
+
+    @Test
+    public void testPow(){
+        testOutput("0^2", "(0^2)", "0");
+        testOutput("2^0", "(2^0)", "1");
+        testOutput("2^1", "(2^1)", "2");
+        testOutput("2^-1", "(2^(1)`)", "0.5");
+        testOutput("2^50", "(2^50)", "112589990684262");
+    }
+
+}

src/test/java/org/nwapw/abacus/tests/TokenizerTests.java

@@ -4,6 +4,7 @@ import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.config.Configuration;
 import org.nwapw.abacus.function.Function;
 import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.function.OperatorAssociativity;
@@ -18,7 +19,7 @@ import java.util.List;
 
 public class TokenizerTests {
 
-    private static Abacus abacus = new Abacus();
+    private static Abacus abacus = new Abacus(new Configuration(0, "precise", new String[]{}),null);
     private static LexerTokenizer lexerTokenizer = new LexerTokenizer();
     private static Function subtractFunction = new Function() {
         @Override