Fix some documentation glitches.

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

README.md

@@ -5,10 +5,10 @@ Summer project for NWAPW.
 Created by Arthur Drobot, Danila Fedorin and Riley Jones.
 
 ## Project Description
-Abacus is a calculator built with extensibility and usability in mind. It provides a plugin interface, via Java, as Lua provides too difficult to link up to the Java core. The description of the internals of the project can be found on the wiki page.
+Abacus is a calculator built with extensibility and usability in mind. It provides a plugin interface, via Java, as Lua proves too difficult to link up to the Java core. The description of the internals of the project can be found on the wiki page.
 
 ## Current State
-Abacus is being built for the Northwest Advanced Programming Workshop, a 3 week program in which students work in treams to complete a single project, following principles of agile development. Because of its short timeframe, Abacus is not even close to completed state. Below is a list of the current features and problems.
+Abacus is being built for the Northwest Advanced Programming Workshop, a 3 week program in which students work in teams to complete a single project, following principles of agile development. Because of its short timeframe, Abacus is not even close to completed state. Below is a list of the current features and problems.
 - [x] Basic number class
 - [x] Implementation of basic functions 
 - [x] Implementation of `exp`, `ln`, `sqrt` using the basic functions and Taylor Series

build.gradle

@@ -1,3 +1,8 @@
+plugins {
+    id 'java'
+    id 'application'
+    id 'org.jetbrains.kotlin.jvm' version '1.1.3'
+}
 apply plugin: 'java'
 apply plugin: 'application'
 
@@ -7,6 +12,7 @@ repositories {
 
 dependencies {
     compile 'com.moandjiezana.toml:toml4j:0.7.1'
+    compile "org.jetbrains.kotlin:kotlin-stdlib-jre8"
     testCompile 'junit:junit:4.12'
 }
 

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

@@ -2,21 +2,16 @@ package org.nwapw.abacus;
 
 import org.nwapw.abacus.config.Configuration;
 import org.nwapw.abacus.fx.AbacusApplication;
-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.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;
-
 /**
  * The main calculator class. This is responsible
  * for piecing together all of the components, allowing
@@ -25,13 +20,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
@@ -55,34 +46,21 @@ public class Abacus {
 
     /**
      * Creates a new instance of the Abacus calculator.
+     *
+     * @param configuration the configuration object for this Abacus instance.
      */
-    public Abacus() {
-        pluginManager = new PluginManager();
+    public Abacus(Configuration configuration) {
+        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();
-    }
-    public void loadClass(Class<?> newClass){
-        pluginManager.addClass(newClass);
-    }
-    public void unloadClass(Class<?> newClass){
-        pluginManager.removeClass(newClass);
+        pluginManager.addListener(lexerTokenizer);
     }
+
     public static void main(String[] args) {
         AbacusApplication.launch(AbacusApplication.class, args);
     }
@@ -153,15 +131,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

@@ -5,6 +5,9 @@ import com.moandjiezana.toml.TomlWriter;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  * The configuration object that stores
@@ -12,52 +15,85 @@ import java.io.IOException;
  */
 public class Configuration {
 
+    /**
+     * The defaults TOML string.
+     */
+    private static final String DEFAULT_CONFIG =
+            "numberImplementation = \"naive\"\n" +
+                    "disabledPlugins = []";
+    /**
+     * The defaults TOML object, parsed from the string.
+     */
+    private static final Toml DEFAULT_TOML = new Toml().read(DEFAULT_CONFIG);
     /**
      * The TOML writer used to write this configuration to a file.
      */
     private static final TomlWriter TOML_WRITER = new TomlWriter();
-    /**
-     * The TOML reader used to load this config from a file.
-     */
-    private static final Toml TOML_READER = new Toml();
 
+    /**
+     * The computation delay for which the thread can run without interruption.
+     */
+    private double computationDelay = 0;
     /**
      * The implementation of the number that should be used.
      */
-    private String numberImplementation = "naive";
+    private String numberImplementation = "<default>";
+    /**
+     * The list of disabled plugins in this Configuration.
+     */
+    private Set<String> disabledPlugins = new HashSet<>();
+
+    /**
+     * Creates a new configuration form the given configuration.
+     *
+     * @param copyFrom the configuration to copy.
+     */
+    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(String numberImplementation){
+    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;
-        copyFrom(TOML_READER.read(fromFile).to(Configuration.class));
+    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);
     }
 
     /**
      * 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) {
@@ -65,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() {
@@ -75,9 +121,39 @@ public class Configuration {
 
     /**
      * Sets the number implementation for the configuration
+     *
      * @param numberImplementation the number implementation.
      */
     public void setNumberImplementation(String numberImplementation) {
         this.numberImplementation = numberImplementation;
     }
+
+    /**
+     * 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/DocumentationType.java

@@ -0,0 +1,7 @@
+package org.nwapw.abacus.function;
+
+public enum DocumentationType {
+
+    FUNCTION
+
+}

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

@@ -1,75 +0,0 @@
-package org.nwapw.abacus.function;
-
-/**
- * A class that represents a single infix operator.
- */
-public class Operator {
-
-    /**
-     * The associativity of the operator.
-     */
-    private OperatorAssociativity associativity;
-    /**
-     * The type of this operator.
-     */
-    private OperatorType type;
-    /**
-     * The precedence of the operator.
-     */
-    private int precedence;
-    /**
-     * The function that is called by this operator.
-     */
-    private Function function;
-
-    /**
-     * Creates a new operator with the given parameters.
-     *
-     * @param associativity the associativity of the operator.
-     * @param precedence    the precedence of the operator.
-     * @param function      the function that the operator calls.
-     */
-    public Operator(OperatorAssociativity associativity, OperatorType operatorType, int precedence, Function function) {
-        this.associativity = associativity;
-        this.type = operatorType;
-        this.precedence = precedence;
-        this.function = function;
-    }
-
-    /**
-     * Gets the operator's associativity.
-     *
-     * @return the associativity.
-     */
-    public OperatorAssociativity getAssociativity() {
-        return associativity;
-    }
-
-    /**
-     * Gets the operator's type.
-     *
-     * @return the type.
-     */
-    public OperatorType getType() {
-        return type;
-    }
-
-    /**
-     * Gets the operator's precedence.
-     *
-     * @return the precedence.
-     */
-    public int getPrecedence() {
-        return precedence;
-    }
-
-    /**
-     * Gets the operator's function.
-     *
-     * @return the function.
-     */
-    public Function getFunction() {
-        return function;
-    }
-
-}

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

@@ -4,5 +4,5 @@ package org.nwapw.abacus.function;
  * The type of an operator, describing how it should behave.
  */
 public enum OperatorType {
-    BINARY_INFIX, UNARY_POSTFIX
+    BINARY_INFIX, UNARY_POSTFIX, UNARY_PREFIX
 }

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,25 +1,61 @@
 package org.nwapw.abacus.fx;
 
+import javafx.application.Platform;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
+import javafx.collections.transformation.FilteredList;
 import javafx.fxml.FXML;
+import javafx.scene.Node;
 import javafx.scene.control.*;
+import javafx.scene.control.cell.CheckBoxListCell;
 import javafx.scene.text.Text;
 import javafx.util.Callback;
+import javafx.util.StringConverter;
 import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.config.Configuration;
+import org.nwapw.abacus.function.Documentation;
+import org.nwapw.abacus.function.DocumentationType;
+import org.nwapw.abacus.number.ComputationInterruptedException;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.plugin.ClassFinder;
+import org.nwapw.abacus.plugin.PluginListener;
+import org.nwapw.abacus.plugin.PluginManager;
+import org.nwapw.abacus.plugin.StandardPlugin;
 import org.nwapw.abacus.tree.TreeNode;
 
+import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 
 /**
  * The controller for the abacus FX UI, responsible
  * for all the user interaction.
  */
-public class AbacusController {
+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.
+     */
+    private static final String APPLY_MSG_TITLE = "\"Apply\" Needed";
+    /**
+     * The text for the header of the apply alert dialog.
+     */
+    private static final String APPLY_MSG_HEADER = "The settings have not been applied.";
+    /**
+     * 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.";
     /**
      * Constant string that is displayed if the text could not be lexed or parsed.
      */
@@ -28,7 +64,22 @@ public class AbacusController {
      * 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 TabPane coreTabPane;
+    @FXML
+    private Tab calculateTab;
+    @FXML
+    private Tab settingsTab;
+    @FXML
+    private Tab functionListTab;
     @FXML
     private TableView<HistoryModel> historyTable;
     @FXML
@@ -44,13 +95,17 @@ public class AbacusController {
     @FXML
     private Button inputButton;
     @FXML
+    private Button stopButton;
+    @FXML
     private ComboBox<String> numberImplementationBox;
     @FXML
-    private Button loadButton;
+    private ListView<ToggleablePlugin> enabledPluginView;
     @FXML
-    private Button unloadButton;
+    private TextField computationLimitField;
     @FXML
-    private TextField loadField;
+    private ListView<Documentation> functionListView;
+    @FXML
+    private TextField functionListSearchField;
 
     /**
      * The list of history entries, created by the users.
@@ -63,90 +118,252 @@ public class AbacusController {
      */
     private ObservableList<String> numberImplementationOptions;
 
+    /**
+     * The list of plugin objects that can be toggled on and off,
+     * and, when reloaded, get added to the plugin manager's black list.
+     */
+    private ObservableList<ToggleablePlugin> enabledPlugins;
+    /**
+     * The list of functions that are registered in the calculator.
+     */
+    private ObservableList<Documentation> functionList;
+    /**
+     * The filtered list displayed to the user.
+     */
+    private FilteredList<Documentation> functionFilter;
+
+    /**
+     * The abacus instance used for changing the plugin configuration.
+     */
     private Abacus abacus;
 
+    /**
+     * Boolean which represents whether changes were made to the configuration.
+     */
+    private boolean changesMade;
+    /**
+     * Whether an alert about changes to the configuration was already shown.
+     */
+    private boolean reloadAlertShown;
+    /**
+     * The alert shown when a press to "apply" is needed.
+     */
+    private Alert reloadAlert;
+    /**
+     * 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)) {
+            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 =
+                param -> new CheckBoxListCell<>(ToggleablePlugin::enabledProperty, new StringConverter<ToggleablePlugin>() {
+                    @Override
+                    public String toString(ToggleablePlugin object) {
+                        return object.getClassName().substring(object.getClassName().lastIndexOf('.') + 1);
+                    }
 
+                    @Override
+                    public ToggleablePlugin fromString(String string) {
+                        return new ToggleablePlugin(true, string);
+                    }
+                });
+        functionList = FXCollections.observableArrayList();
+        functionFilter = new FilteredList<>(functionList, (s) -> true);
+        functionListView.setItems(functionFilter);
+        functionListSearchField.textProperty().addListener((observable, oldValue, newValue) ->
+                functionFilter.setPredicate((newValue.length() == 0) ? ((s) -> true) : ((s) -> s.matches(newValue))));
+        functionListView.setCellFactory(param -> new DocumentationCell());
         historyData = FXCollections.observableArrayList();
         historyTable.setItems(historyData);
         numberImplementationOptions = FXCollections.observableArrayList();
         numberImplementationBox.setItems(numberImplementationOptions);
-        numberImplementationBox.valueProperty().addListener((observable, oldValue, newValue)
-                -> {
-            abacus.getConfiguration().setNumberImplementation(newValue);
-            abacus.getConfiguration().saveTo(Abacus.CONFIG_FILE);
-        });
+        numberImplementationBox.getSelectionModel().selectedIndexProperty().addListener(e -> changesMade = true);
         historyTable.getSelectionModel().setCellSelectionEnabled(true);
+        enabledPlugins = FXCollections.observableArrayList();
+        enabledPluginView.setItems(enabledPlugins);
+        enabledPluginView.setCellFactory(pluginCellFactory);
         inputColumn.setCellFactory(cellFactory);
         inputColumn.setCellValueFactory(cell -> cell.getValue().inputProperty());
         parsedColumn.setCellFactory(cellFactory);
         parsedColumn.setCellValueFactory(cell -> cell.getValue().parsedProperty());
         outputColumn.setCellFactory(cellFactory);
         outputColumn.setCellValueFactory(cell -> cell.getValue().outputProperty());
+        coreTabPane.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> {
+            if (oldValue.equals(settingsTab)) alertIfApplyNeeded(true);
+        });
 
-        abacus = new Abacus();
-        numberImplementationOptions.addAll(abacus.getPluginManager().getAllNumbers());
-        String actualImplementation = abacus.getConfiguration().getNumberImplementation();
-        String toSelect = (numberImplementationOptions.contains(actualImplementation)) ? actualImplementation : "naive";
-        numberImplementationBox.getSelectionModel().select(toSelect);
+        abacus = new Abacus(new Configuration(CONFIG_FILE));
+        PluginManager abacusPluginManager = abacus.getPluginManager();
+        abacusPluginManager.addListener(this);
+        abacusPluginManager.addInstantiated(new StandardPlugin(abacus.getPluginManager()));
+        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;
+
+        reloadAlert = new Alert(Alert.AlertType.WARNING);
+        reloadAlert.setTitle(APPLY_MSG_TITLE);
+        reloadAlert.setHeaderText(APPLY_MSG_HEADER);
+        reloadAlert.setContentText(APPLY_MSG_TEXT);
     }
 
     @FXML
-    private void performCalculation(){
+    public void performCalculation() {
         inputButton.setDisable(true);
-        TreeNode constructedTree = abacus.parseString(inputField.getText());
-        if(constructedTree == null){
-            outputText.setText(ERR_SYNTAX);
-            inputButton.setDisable(false);
-            return;
-        }
-        NumberInterface evaluatedNumber = abacus.evaluateTree(constructedTree);
-        if(evaluatedNumber == null){
-            outputText.setText(ERR_EVAL);
-            inputButton.setDisable(false);
-            return;
-        }
-        outputText.setText(evaluatedNumber.toString());
-        historyData.add(new HistoryModel(inputField.getText(), constructedTree.toString(), evaluatedNumber.toString()));
+        stopButton.setDisable(false);
+        calculationThread = new Thread(CALCULATION_RUNNABLE);
+        calculationThread.start();
+        computationLimitThread = new Thread(TIMER_RUNNABLE);
+        computationLimitThread.start();
+    }
 
-        inputButton.setDisable(false);
-        inputField.setText("");
-    }
     @FXML
-    private void loadClass(){
-        try {
-            for(Class<?> plugin :ClassFinder.loadJars("plugins")){
-                String name = "";
-                //String name = plugin.getName();
-                while(!(name.indexOf('/') ==-1)){
-                    name=name.substring(name.indexOf('/')+1);
-                }
-                if(loadField.getText().equals("")||loadField.getText().equals(name)||(loadField.getText()+".class").equals(name)){
-                    //abacus.loadClass(plugin);
-                }
-            }
-        } catch (IOException | ClassNotFoundException e) {
-            e.printStackTrace();
+    public void performStop(){
+        if(calculationThread != null) {
+            calculationThread.interrupt();
+            calculationThread = null;
+        }
+        if(computationLimitThread != null){
+            computationLimitThread.interrupt();
+            computationLimitThread = null;
         }
     }
+
     @FXML
-    private void unloadClass(){
-        try {
-            for(Class<?> plugin :ClassFinder.loadJars("plugins")){
-                String name = plugin.getName();
-                while(!(name.indexOf('/') ==-1)){
-                    name=name.substring(name.indexOf('/')+1);
-                }
-                if(loadField.getText().equals("")||loadField.getText().equals(name)||(loadField.getText()+".class").equals(name)){
-                    //abacus.unloadClass(plugin);
-                }
-            }
-        } catch (IOException | ClassNotFoundException e) {
-            e.printStackTrace();
+    public void performSaveAndReload() {
+        performSave();
+        performReload();
+        changesMade = false;
+        reloadAlertShown = false;
+    }
+
+    @FXML
+    public void performReload() {
+        alertIfApplyNeeded(true);
+        abacus.getPluginManager().reload();
+    }
+
+    @FXML
+    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());
         }
+        if(computationLimitField.getText().matches("\\d*(\\.\\d+)?") && computationLimitField.getText().length() != 0)
+            configuration.setComputationDelay(Double.parseDouble(computationLimitField.getText()));
+        configuration.saveTo(CONFIG_FILE);
+        changesMade = false;
+        reloadAlertShown = false;
+    }
+
+    @Override
+    public void onLoad(PluginManager manager) {
+        Configuration configuration = abacus.getConfiguration();
+        Set<String> disabledPlugins = configuration.getDisabledPlugins();
+        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()) {
+            String fullName = pluginClass.getName();
+            ToggleablePlugin plugin = new ToggleablePlugin(!disabledPlugins.contains(fullName), fullName);
+            plugin.enabledProperty().addListener(e -> changesMade = true);
+            enabledPlugins.add(plugin);
+        }
+        PluginManager pluginManager = abacus.getPluginManager();
+        functionList.addAll(manager.getAllFunctions().stream().map(name -> pluginManager.documentationFor(name, DocumentationType.FUNCTION))
+                .collect(Collectors.toCollection(ArrayList::new)));
+        functionList.sort(Comparator.comparing(Documentation::getCodeName));
+    }
+
+    @Override
+    public void onUnload(PluginManager manager) {
+        functionList.clear();
+        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/DocumentationCell.java

@@ -0,0 +1,58 @@
+package org.nwapw.abacus.fx;
+
+import javafx.scene.control.Label;
+import javafx.scene.control.ListCell;
+import javafx.scene.control.TitledPane;
+import javafx.scene.layout.VBox;
+import org.nwapw.abacus.function.Documentation;
+
+public class DocumentationCell extends ListCell<Documentation> {
+
+    private Label codeNameLabel;
+    private Label nameLabel;
+    private Label description;
+    private Label longDescription;
+    private TitledPane titledPane;
+
+    public DocumentationCell(){
+        VBox vbox = new VBox();
+        vbox.setSpacing(10);
+        titledPane = new TitledPane();
+        codeNameLabel = new Label();
+        nameLabel = new Label();
+        description = new Label();
+        longDescription = new Label();
+        codeNameLabel.setWrapText(true);
+        nameLabel.setWrapText(true);
+        description.setWrapText(true);
+        longDescription.setWrapText(true);
+        vbox.getChildren().add(codeNameLabel);
+        vbox.getChildren().add(nameLabel);
+        vbox.getChildren().add(description);
+        vbox.getChildren().add(longDescription);
+        titledPane.textProperty().bindBidirectional(codeNameLabel.textProperty());
+        titledPane.setContent(vbox);
+        titledPane.setExpanded(false);
+        titledPane.prefWidthProperty().bind(widthProperty());
+
+        visibleProperty().addListener((a, b, c) -> titledPane.setExpanded(false));
+    }
+
+    @Override
+    protected void updateItem(Documentation item, boolean empty) {
+        super.updateItem(item, empty);
+        if(empty){
+            codeNameLabel.setText("");
+            nameLabel.setText("");
+            description.setText("");
+            longDescription.setText("");
+            setGraphic(null);
+        } else {
+            codeNameLabel.setText(item.getCodeName());
+            nameLabel.setText(item.getName());
+            description.setText(item.getDescription());
+            longDescription.setText(item.getLongDescription());
+            setGraphic(titledPane);
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+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;
+
+    /**
+     * 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/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.
      *
@@ -41,32 +42,32 @@ public class NaiveNumber implements NumberInterface {
     }
 
     @Override
-    public NumberInterface multiply(NumberInterface multiplier) {
+    public NumberInterface multiplyInternal(NumberInterface multiplier) {
         return new NaiveNumber(value * ((NaiveNumber) multiplier).value);
     }
 
     @Override
-    public NumberInterface divide(NumberInterface divisor) {
+    public NumberInterface divideInternal(NumberInterface divisor) {
         return new NaiveNumber(value / ((NaiveNumber) divisor).value);
     }
 
     @Override
-    public NumberInterface add(NumberInterface summand) {
+    public NumberInterface addInternal(NumberInterface summand) {
         return new NaiveNumber(value + ((NaiveNumber) summand).value);
     }
 
     @Override
-    public NumberInterface subtract(NumberInterface subtrahend) {
+    public NumberInterface subtractInternal(NumberInterface subtrahend) {
         return new NaiveNumber(value - ((NaiveNumber) subtrahend).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;
         }
@@ -94,12 +95,27 @@ 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));

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

@@ -3,14 +3,22 @@ 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();
+    }
     /**
      * 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 +27,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 +50,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 +73,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 +96,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 +118,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 +140,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 +161,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.
+     */
+    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.
+     */
+    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 than or equal to the number.
+     */
+    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, specifically x - floor(x).
+     * 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 +240,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) {
+    public NumberInterface multiplyInternal(NumberInterface multiplier) {
         return new PreciseNumber(this.value.multiply(((PreciseNumber) multiplier).value));
     }
 
     @Override
-    public NumberInterface divide(NumberInterface divisor) {
+    public NumberInterface divideInternal(NumberInterface divisor) {
         return new PreciseNumber(value.divide(((PreciseNumber) divisor).value, this.getMaxPrecision(), RoundingMode.HALF_UP));
     }
 
     @Override
-    public NumberInterface add(NumberInterface summand) {
+    public NumberInterface addInternal(NumberInterface summand) {
         return new PreciseNumber(value.add(((PreciseNumber) summand).value));
     }
 
     @Override
-    public NumberInterface subtract(NumberInterface subtrahend) {
+    public NumberInterface subtractInternal(NumberInterface subtrahend) {
         return new PreciseNumber(value.subtract(((PreciseNumber) subtrahend).value));
     }
 
     @Override
-    public NumberInterface intPow(int exponent) {
+    public NumberInterface intPowInternal(int exponent) {
         if (exponent == 0) {
             return PreciseNumber.ONE;
         }
@@ -99,17 +99,46 @@ 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) {
+            NumberInterface floor = new PreciseNumber(str.substring(0, decimalIndex));
+            if(signum() == -1){
+                floor = floor.subtract(ONE);
+            }
+            return floor;
+        }
+        return this;
+    }
+
+    @Override
+    public NumberInterface fractionalPartInternal() {
+        return this.subtractInternal(floorInternal());
+    }
+
+    @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/parsing/ShuntingYardParser.java

@@ -55,9 +55,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
     public List<Match<TokenType>> intoPostfix(List<Match<TokenType>> from) {
         ArrayList<Match<TokenType>> output = new ArrayList<>();
         Stack<Match<TokenType>> tokenStack = new Stack<>();
+        TokenType previousType;
+        TokenType matchType = null;
         while (!from.isEmpty()) {
             Match<TokenType> match = from.remove(0);
-            TokenType matchType = match.getType();
+            previousType = matchType;
+            matchType = match.getType();
             if (matchType == TokenType.NUM) {
                 output.add(match);
             } else if (matchType == TokenType.FUNCTION) {
@@ -74,13 +77,19 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                     continue;
                 }
 
-                while (!tokenStack.empty()) {
+                if (tokenString.equals("-") && (previousType == null || previousType == TokenType.OP ||
+                        previousType == TokenType.OPEN_PARENTH)) {
+                    from.add(0, new Match<>("`", TokenType.OP));
+                    continue;
+                }
+
+                while (!tokenStack.empty() && type == OperatorType.BINARY_INFIX) {
                     Match<TokenType> otherMatch = tokenStack.peek();
                     TokenType otherMatchType = otherMatch.getType();
                     if (!(otherMatchType == TokenType.OP || otherMatchType == TokenType.FUNCTION)) break;
 
                     if (otherMatchType == TokenType.OP) {
-                        int otherPrecedence = precedenceMap.get(match.getContent());
+                        int otherPrecedence = precedenceMap.get(otherMatch.getContent());
                         if (otherPrecedence < precedence ||
                                 (associativity == OperatorAssociativity.RIGHT && otherPrecedence == precedence)) {
                             break;
@@ -103,8 +112,8 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
         }
         while (!tokenStack.empty()) {
             Match<TokenType> match = tokenStack.peek();
-            TokenType matchType = match.getType();
-            if (!(matchType == TokenType.OP || matchType == TokenType.FUNCTION)) return null;
+            TokenType newMatchType = match.getType();
+            if (!(newMatchType == TokenType.OP || newMatchType == TokenType.FUNCTION)) return null;
             output.add(tokenStack.pop());
         }
         return output;
@@ -127,11 +136,11 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                 TreeNode right = constructRecursive(matches);
                 TreeNode left = constructRecursive(matches);
                 if (left == null || right == null) return null;
-                else return new BinaryInfixNode(operator, left, right);
+                else return new BinaryNode(operator, left, right);
             } else {
                 TreeNode applyTo = constructRecursive(matches);
                 if (applyTo == null) return null;
-                else return new UnaryPrefixNode(operator, applyTo);
+                else return new UnaryNode(operator, applyTo);
             }
         } else if (matchType == TokenType.NUM) {
             return new NumberNode(abacus.numberFromString(match.getContent()));
@@ -153,8 +162,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

@@ -1,5 +1,7 @@
 package org.nwapw.abacus.plugin;
 
+import org.nwapw.abacus.function.Documentation;
+import org.nwapw.abacus.function.DocumentationType;
 import org.nwapw.abacus.function.Function;
 import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.number.NumberInterface;
@@ -17,18 +19,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 +39,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 +59,6 @@ public abstract class Plugin {
     public final void disable() {
         if (!enabled) return;
         onDisable();
-        functions.clear();
-        operators.clear();
         enabled = false;
     }
 
@@ -142,7 +70,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 +82,27 @@ 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);
+    }
+
+    /**
+     * To be used in load(). Registers a documentation instance
+     * used to explain some element of the plugin to the user.
+     * @param documentation the documentation instance.
+     */
+    protected final void registerDocumentation(Documentation documentation){
+        manager.registerDocumentation(documentation);
     }
 
     /**
@@ -194,6 +129,42 @@ 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 PluginManager for the given documentation name and type.
+     *
+     * @param name the name for which to search.
+     * @param type the type of documentation to search for.
+     * @return the found documentation, or null if none was found.
+     */
+    protected final Documentation documentationFor(String name, DocumentationType type){
+        return manager.documentationFor(name, type);
+    }
+
+    /**
+     * 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

@@ -1,5 +1,8 @@
 package org.nwapw.abacus.plugin;
 
+import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.function.Documentation;
+import org.nwapw.abacus.function.DocumentationType;
 import org.nwapw.abacus.function.Function;
 import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.number.NumberInterface;
@@ -22,112 +25,177 @@ 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 map of documentation for functions registered by the plugins.
      */
-    private Set<String> allFunctions;
+    private Set<Documentation> registeredDocumentation;
     /**
-     * List of all operators loaded by the plugins.
+     * The list of number implementations that have been
+     * found by their implementation class.
      */
-    private Set<String> allOperators;
+    private Map<Class<? extends NumberInterface>, NumberImplementation> cachedInterfaceImplementations;
     /**
-     * List of all numbers loaded by the plugins.
+     * The pi values for each implementation class that have already been computer.
      */
-    private Set<String> allNumbers;
+    private Map<Class<? extends NumberInterface>, NumberInterface> cachedPi;
     /**
      * The list of plugin listeners attached to this instance.
      */
     private Set<PluginListener> listeners;
+    /**
+     * The abacus instance used to access other
+     * components of the application.
+     */
+    private Abacus abacus;
 
     /**
      * Creates a new plugin manager.
+     *
+     * @param abacus the abacus instance.
      */
-    public PluginManager() {
+    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<>();
+        registeredDocumentation = new HashSet<>();
+        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);
+    }
+
+    /**
+     * Registers the given documentation with the plugin manager,
+     * making it accessible to the plugin manager etc.
+     * @param documentation the documentation to register.
+     */
+    public void registerDocumentation(Documentation documentation){
+        registeredDocumentation.add(documentation);
+    }
+
+    /**
+     * 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 documentation for the given entity of the given type.
+     * @param name the name of the entity to search for.
+     * @param type the type that this entity is, to filter out similarly named documentation.
+     * @return the documentation object.
+     */
+    public Documentation documentationFor(String name, DocumentationType type){
+        Documentation toReturn = null;
+        for(Documentation entry : registeredDocumentation){
+            if(entry.getCodeName().equals(name) && entry.getType() == type) {
+                toReturn = entry;
                 break;
             }
         }
-
-        cache.put(name, loadedValue);
-        return loadedValue;
+        if(toReturn == null){
+            toReturn = new Documentation(name, "", "", "", type);
+            registerDocumentation(toReturn);
+        }
+        return toReturn;
     }
 
     /**
-     * Gets a function under the given name.
+     * Gets the number implementation for the given implementation class.
      *
-     * @param name the name of the function
-     * @return the function under the given name.
+     * @param name the class for which to find the implementation.
+     * @return the implementation.
      */
-    public Function functionFor(String name) {
-        return searchCached(plugins, cachedFunctions, Plugin::providedFunctions, Plugin::getFunction, name);
+    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;
+            }
+        }
+        cachedInterfaceImplementations.put(name, toReturn);
+        return toReturn;
     }
 
     /**
-     * Gets an operator under the given name.
+     * Gets the mathematical constant pi for the given implementation class.
      *
-     * @param name the name of the operator.
-     * @return the operator under the given name.
+     * @param forClass the class for which to find pi.
+     * @return pi
      */
-    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;
     }
 
     /**
@@ -140,11 +208,6 @@ public class PluginManager {
         plugins.add(plugin);
         loadedPluginClasses.add(plugin.getClass());
     }
-    public void removeInstantiated(Plugin plugin){
-        if (loadedPluginClasses.contains(plugin.getClass())) return;
-        plugins.remove(plugin);
-        loadedPluginClasses.remove(plugin.getClass());
-    }
 
     /**
      * Instantiates a class of plugin, and adds it to this
@@ -160,24 +223,15 @@ public class PluginManager {
             e.printStackTrace();
         }
     }
-    public void removeClass(Class<?> newClass){
-        if (!Plugin.class.isAssignableFrom(newClass) || newClass == Plugin.class) return;
-        try {
-            removeInstantiated((Plugin) newClass.getConstructor(PluginManager.class).newInstance(this));
-        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-    }
 
     /**
      * Loads all the plugins in the PluginManager.
      */
     public void load() {
-        for (Plugin plugin : plugins) plugin.enable();
+        Set<String> disabledPlugins = abacus.getConfiguration().getDisabledPlugins();
         for (Plugin plugin : plugins) {
-            allFunctions.addAll(plugin.providedFunctions());
-            allOperators.addAll(plugin.providedOperators());
-            allNumbers.addAll(plugin.providedNumbers());
+            if (disabledPlugins.contains(plugin.getClass().getName())) continue;
+            plugin.enable();
         }
         listeners.forEach(e -> e.onLoad(this));
     }
@@ -186,10 +240,18 @@ public class PluginManager {
      * Unloads all the plugins in the PluginManager.
      */
     public void unload() {
-        for (Plugin plugin : plugins) plugin.disable();
-        allFunctions.clear();
-        allOperators.clear();
-        allNumbers.clear();
+        listeners.forEach(e -> e.onUnload(this));
+        Set<String> disabledPlugins = abacus.getConfiguration().getDisabledPlugins();
+        for (Plugin plugin : plugins) {
+            if (disabledPlugins.contains(plugin.getClass().getName())) continue;
+            plugin.disable();
+        }
+        registeredFunctions.clear();
+        registeredOperators.clear();
+        registeredNumberImplementations.clear();
+        registeredDocumentation.clear();
+        cachedInterfaceImplementations.clear();
+        cachedPi.clear();
         listeners.forEach(e -> e.onUnload(this));
     }
 
@@ -198,7 +260,7 @@ public class PluginManager {
      */
     public void reload() {
         unload();
-        reload();
+        load();
     }
 
     /**
@@ -207,7 +269,7 @@ public class PluginManager {
      * @return the set of all functions that were loaded.
      */
     public Set<String> getAllFunctions() {
-        return allFunctions;
+        return registeredFunctions.keySet();
     }
 
     /**
@@ -216,16 +278,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();
     }
 
     /**
@@ -246,4 +308,13 @@ public class PluginManager {
         listeners.remove(listener);
     }
 
+    /**
+     * 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() {
+        return loadedPluginClasses;
+    }
 }

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

@@ -1,15 +1,18 @@
 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.function.*;
+import org.nwapw.abacus.lexing.pattern.Match;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.number.PreciseNumber;
+import org.nwapw.abacus.parsing.Parser;
+import org.nwapw.abacus.parsing.ShuntingYardParser;
+import org.nwapw.abacus.tree.TokenType;
+import org.nwapw.abacus.tree.TreeNode;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.function.BiFunction;
 
 /**
@@ -18,7 +21,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 +56,21 @@ public class StandardPlugin extends Plugin {
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
             return params[0].subtract(params[1]);
+
+        }
+    });
+    /**
+     * The negation operator, -
+     */
+    public static final Operator OP_NEGATE = new Operator(OperatorAssociativity.LEFT, OperatorType.UNARY_PREFIX, 0, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return params[0].negate();
         }
     });
     /**
@@ -76,16 +97,12 @@ 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 >= 1;
+            return params.length == 2 && params[1].compareTo(NaiveNumber.ZERO.promoteTo(params[1].getClass())) != 0;
         }
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
-            NumberInterface product = params[0];
-            for (int i = 1; i < params.length; i++) {
-                product = product.multiply(params[i]);
-            }
-            return product;
+            return params[0].divide(params[1]);
         }
     });
     /**
@@ -95,13 +112,15 @@ 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].getClass())) == 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].getClass(), 1);
             }
             NumberInterface factorial = params[0];
             NumberInterface multiplier = params[0];
@@ -117,20 +136,6 @@ public class StandardPlugin extends Plugin {
                 }*/
         }
     });
-    /**
-     * 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
      */
@@ -145,74 +150,31 @@ public class StandardPlugin extends Plugin {
             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;
-            }
-        }
-    };
     /**
      * The natural log function.
      */
     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].getClass())) > 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) {
+            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()));
+                    param = param.divide(fromInt(param.getClass(), 2));
                     powersOf2++;
                     if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
                         break;
                         //No infinite loop for you.
                     }
                 } else {
-                    param = param.multiply(new NaiveNumber(2).promoteTo(param.getClass()));
+                    param = param.multiply(fromInt(param.getClass(), 2));
                     powersOf2--;
-                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != -1) {
                         break;
                         //No infinite loop for you.
                     }
@@ -228,6 +190,7 @@ 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).
             NumberInterface currentNumerator = x, currentTerm = x, sum = x;
@@ -248,17 +211,17 @@ 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.getClass(), 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 a = fromInt(number.getClass(), 1), b = a, c = a;
             NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClass());
             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()));
+                a = a.divide(fromInt(number.getClass(), 3));
+                b = b.divide(fromInt(number.getClass(), 4));
                 c = NaiveNumber.ONE.promoteTo(number.getClass()).divide((new NaiveNumber(n)).promoteTo(number.getClass()));
                 sum = sum.add(a.add(b).multiply(c));
             }
@@ -279,6 +242,222 @@ public class StandardPlugin extends Plugin {
             return OP_CARET.getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
         }
     };
+    /**
+     * 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].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(fromInt(params[0].getClass(), 3).intPow(params[0].ceiling().intValue())), 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;
+            }
+        }
+    };
+    /**
+     * 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].getClass())) == 0
+                    && params[1].compareTo(NaiveNumber.ZERO.promoteTo(params[1].getClass())) == 0)
+                    && !(params[0].signum() == -1 && params[1].fractionalPart().compareTo(NaiveNumber.ZERO.promoteTo(params[1].getClass())) != 0);
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            if (params[0].compareTo(NaiveNumber.ZERO.promoteTo(params[0].getClass())) == 0)
+                return NaiveNumber.ZERO.promoteTo(params[0].getClass());
+            else if (params[1].compareTo(NaiveNumber.ZERO.promoteTo(params[0].getClass())) == 0)
+                return NaiveNumber.ONE.promoteTo(params[1].getClass());
+            //Detect integer bases:
+            if(params[0].fractionalPart().compareTo(fromInt(params[0].getClass(), 0)) == 0
+                    && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), Integer.MAX_VALUE)) < 0
+                    && FUNCTION_ABS.apply(params[1]).compareTo(fromInt(params[1].getClass(), 1)) >= 0){
+                NumberInterface[] newParams = {params[0], params[1].fractionalPart()};
+                return params[0].intPow(params[1].floor().intValue()).multiply(applyInternal(newParams));
+            }
+            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].getClass());
+            NumberInterface twoPi = pi.multiply(fromInt(pi.getClass(), 2));
+            NumberInterface theta = getSmallAngle(params[0], pi);
+            //System.out.println(theta);
+            if (theta.compareTo(pi.multiply(new NaiveNumber(1.5).promoteTo(twoPi.getClass()))) >= 0) {
+                theta = theta.subtract(twoPi);
+            } else if (theta.compareTo(pi.divide(fromInt(pi.getClass(), 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].getClass()).divide(fromInt(params[0].getClass(), 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].getClass()).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].getClass()).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]));
+        }
+    };
 
     public StandardPlugin(PluginManager manager) {
         super(manager);
@@ -307,16 +486,91 @@ 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.getClass(), 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.getClass(), 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.getClass()));
+        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);
+        registerOperator("`", OP_NEGATE);
         registerOperator("*", OP_MULTIPLY);
         registerOperator("/", OP_DIVIDE);
         registerOperator("^", OP_CARET);
@@ -326,26 +580,45 @@ 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);
+
+        registerDocumentation(new Documentation("abs", "Absolute Value", "Finds the distance " +
+                "from zero of a number.", "Given a number, this function finds the distance form " +
+                "zero of a number, effectively turning negative numbers into positive ones.\n\n" +
+                "Example: abs(-2) -> 2", DocumentationType.FUNCTION));
+        registerDocumentation(new Documentation("exp", "Exponentiate", "Brings e to the given power.",
+                "This function evaluates e to the power of the given value, and is the inverse " +
+                        "of the natural logarithm.\n\n" +
+                        "Example: exp(1) -> 2.718...", DocumentationType.FUNCTION));
+        registerDocumentation(new Documentation("ln", "Natural Logarithm", "Gets the natural " +
+                "logarithm of the given value.", "The natural logarithm of a number is " +
+                "the power that e has to be brought to to be equal to the number.\n\n" +
+                "Example: ln(2.718) -> 1", DocumentationType.FUNCTION));
+        registerDocumentation(new Documentation("sqrt", "Square Root", "Finds the square root " +
+                "of the number.", "A square root a of a number is defined such that a times a is equal " +
+                "to that number.\n\n" +
+                "Example: sqrt(4) -> 2", DocumentationType.FUNCTION));
+        registerDocumentation(new Documentation("sin", "Sine", "Computes the sine of the given angle, " +
+                "in radians.", "", DocumentationType.FUNCTION));
+        registerDocumentation(new Documentation("cos", "Cosine", "Computes the cosine of the given angle, " +
+                "in radians.", "", DocumentationType.FUNCTION));
+        registerDocumentation(new Documentation("tan", "Tangent", "Computes the tangent of the given angle, " +
+                "in radians.", "", DocumentationType.FUNCTION));
+        registerDocumentation(new Documentation("sec", "Secant", "Computes the secant of the given angle, " +
+                "in radians.", "", DocumentationType.FUNCTION));
+        registerDocumentation(new Documentation("csc", "Cosecant", "Computes the cosecant of the given angle, " +
+                "in radians.", "", DocumentationType.FUNCTION));
+        registerDocumentation(new Documentation("cot", "Cotangent", "Computes the cotangent of the given angle, " +
+                "in radians.", "", DocumentationType.FUNCTION));
     }
 
     @Override
     public void onDisable() {
 
     }
-
-    public static NumberInterface factorial(Class<? extends NumberInterface> numberClass, int n){
-        if(!factorialLists.containsKey(numberClass)){
-            factorialLists.put(numberClass, new ArrayList<NumberInterface>());
-            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/tree/BinaryInfixNode.java

@@ -1,108 +0,0 @@
-package org.nwapw.abacus.tree;
-
-/**
- * A tree node that represents an operation being applied to two operands.
- */
-public class BinaryInfixNode extends TreeNode {
-
-    /**
-     * The operation being applied.
-     */
-    private String operation;
-    /**
-     * The left node of the operation.
-     */
-    private TreeNode left;
-    /**
-     * The right node of the operation.
-     */
-    private TreeNode right;
-
-    private BinaryInfixNode() {
-    }
-
-    /**
-     * Creates a new operation node with the given operation
-     * and no child nodes.
-     *
-     * @param operation the operation.
-     */
-    public BinaryInfixNode(String operation) {
-        this(operation, null, null);
-    }
-
-    /**
-     * Creates a new operation node with the given operation
-     * and child nodes.
-     *
-     * @param operation the operation.
-     * @param left      the left node of the expression.
-     * @param right     the right node of the expression.
-     */
-    public BinaryInfixNode(String operation, TreeNode left, TreeNode right) {
-        this.operation = operation;
-        this.left = left;
-        this.right = right;
-    }
-
-    /**
-     * Gets the operation in this node.
-     *
-     * @return the operation in this node.
-     */
-    public String getOperation() {
-        return operation;
-    }
-
-    /**
-     * Gets the left sub-expression of this node.
-     *
-     * @return the left node.
-     */
-    public TreeNode getLeft() {
-        return left;
-    }
-
-    /**
-     * Sets the left sub-expression of this node.
-     *
-     * @param left the sub-expression to apply.
-     */
-    public void setLeft(TreeNode left) {
-        this.left = left;
-    }
-
-    /**
-     * Gets the right sub-expression of this node.
-     *
-     * @return the right node.
-     */
-    public TreeNode getRight() {
-        return right;
-    }
-
-    /**
-     * Sets the right sub-expression of this node.
-     *
-     * @param right the sub-expression to apply.
-     */
-    public void setRight(TreeNode right) {
-        this.right = right;
-    }
-
-    @Override
-    public <T> T reduce(Reducer<T> reducer) {
-        T leftReduce = left.reduce(reducer);
-        T rightReduce = right.reduce(reducer);
-        if (leftReduce == null || rightReduce == null) return null;
-        return reducer.reduceNode(this, leftReduce, rightReduce);
-    }
-
-    @Override
-    public String toString() {
-        String leftString = left != null ? left.toString() : "null";
-        String rightString = right != null ? right.toString() : "null";
-
-        return "(" + leftString + operation + rightString + ")";
-    }
-}

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

@@ -1,85 +0,0 @@
-package org.nwapw.abacus.tree;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * A node that represents a function call.
- */
-public class FunctionNode extends TreeNode {
-
-    /**
-     * The name of the function being called
-     */
-    private String function;
-    /**
-     * The list of arguments to the function.
-     */
-    private List<TreeNode> children;
-
-    /**
-     * Creates a function node with no function.
-     */
-    private FunctionNode() {
-    }
-
-    /**
-     * Creates a new function node with the given function name.
-     *
-     * @param function the function name.
-     */
-    public FunctionNode(String function) {
-        this.function = function;
-        children = new ArrayList<>();
-    }
-
-    /**
-     * Gets the function name for this node.
-     *
-     * @return the function name.
-     */
-    public String getFunction() {
-        return function;
-    }
-
-    /**
-     * Adds a child to the end of this node's child list.
-     *
-     * @param node the child to add.
-     */
-    public void appendChild(TreeNode node) {
-        children.add(node);
-    }
-
-    /**
-     * Adds a new child to the beginning of this node's child list.
-     *
-     * @param node the node to add.
-     */
-    public void prependChild(TreeNode node) {
-        children.add(0, node);
-    }
-
-    @Override
-    public <T> T reduce(Reducer<T> reducer) {
-        Object[] reducedChildren = new Object[children.size()];
-        for (int i = 0; i < reducedChildren.length; i++) {
-            reducedChildren[i] = children.get(i).reduce(reducer);
-            if (reducedChildren[i] == null) return null;
-        }
-        return reducer.reduceNode(this, reducedChildren);
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder buffer = new StringBuilder();
-        buffer.append(function);
-        buffer.append("(");
-        for (int i = 0; i < children.size(); i++) {
-            buffer.append(children.get(i));
-            buffer.append(i == children.size() - 1 ? "" : ", ");
-        }
-        buffer.append(")");
-        return buffer.toString();
-    }
-}

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

@@ -1,49 +0,0 @@
-package org.nwapw.abacus.tree;
-
-import org.nwapw.abacus.number.NumberInterface;
-
-/**
- * A node implementation that represents a single number.
- */
-public class NumberNode extends TreeNode {
-
-    /**
-     * The number that is represented by this number node.
-     */
-    private NumberInterface number;
-
-    /**
-     * Creates a number node with no number.
-     */
-    public NumberNode() {
-        number = null;
-    }
-
-    /**
-     * Creates a new number node with the given double value.
-     *
-     * @param newNumber the number for which to create a number node.
-     */
-    public NumberNode(NumberInterface newNumber) {
-        this.number = newNumber;
-    }
-
-    /**
-     * Gets the number value of this node.
-     *
-     * @return the number value of this node.
-     */
-    public NumberInterface getNumber() {
-        return number;
-    }
-
-    @Override
-    public <T> T reduce(Reducer<T> reducer) {
-        return reducer.reduceNode(this);
-    }
-
-    @Override
-    public String toString() {
-        return number != null ? number.toString() : "null";
-    }
-}

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

@@ -28,15 +28,15 @@ public class NumberReducer implements Reducer<NumberInterface> {
     public NumberInterface reduceNode(TreeNode node, Object... children) {
         if (node instanceof NumberNode) {
             return ((NumberNode) node).getNumber();
-        } else if (node instanceof BinaryInfixNode) {
+        } else if (node instanceof BinaryNode) {
             NumberInterface left = (NumberInterface) children[0];
             NumberInterface right = (NumberInterface) children[1];
-            Function function = abacus.getPluginManager().operatorFor(((BinaryInfixNode) node).getOperation()).getFunction();
+            Function function = abacus.getPluginManager().operatorFor(((BinaryNode) node).getOperation()).getFunction();
             if (function == null) return null;
             return function.apply(left, right);
-        } else if (node instanceof UnaryPrefixNode) {
+        } else if (node instanceof UnaryNode) {
             NumberInterface child = (NumberInterface) children[0];
-            Function functionn = abacus.getPluginManager().operatorFor(((UnaryPrefixNode) node).getOperation()).getFunction();
+            Function functionn = abacus.getPluginManager().operatorFor(((UnaryNode) node).getOperation()).getFunction();
             if (functionn == null) return null;
             return functionn.apply(child);
         } else if (node instanceof FunctionNode) {

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

@@ -1,17 +0,0 @@
-package org.nwapw.abacus.tree;
-
-/**
- * An abstract class that represents an expression tree node.
- */
-public abstract class TreeNode {
-
-    /**
-     * The function that reduces a tree to a single vale.
-     *
-     * @param reducer the reducer used to reduce the tree.
-     * @param <T>     the type the reducer produces.
-     * @return the result of the reduction, or null on error.
-     */
-    public abstract <T> T reduce(Reducer<T> reducer);
-
-}

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

@@ -1,63 +0,0 @@
-package org.nwapw.abacus.tree;
-
-public class UnaryPrefixNode extends TreeNode {
-
-    /**
-     * The operation this node will apply.
-     */
-    private String operation;
-    /**
-     * The tree node to apply the operation to.
-     */
-    private TreeNode applyTo;
-
-    /**
-     * Creates a new node with the given operation and no child.
-     *
-     * @param operation the operation for this node.
-     */
-    public UnaryPrefixNode(String operation) {
-        this(operation, null);
-    }
-
-    /**
-     * Creates a new node with the given operation and child.
-     *
-     * @param operation the operation for this node.
-     * @param applyTo   the node to apply the function to.
-     */
-    public UnaryPrefixNode(String operation, TreeNode applyTo) {
-        this.operation = operation;
-        this.applyTo = applyTo;
-    }
-
-    @Override
-    public <T> T reduce(Reducer<T> reducer) {
-        Object reducedChild = applyTo.reduce(reducer);
-        if (reducedChild == null) return null;
-        return reducer.reduceNode(this, reducedChild);
-    }
-
-    /**
-     * Gets the operation of this node.
-     *
-     * @return the operation this node performs.
-     */
-    public String getOperation() {
-        return operation;
-    }
-
-    /**
-     * Gets the node to which this node's operation applies.
-     *
-     * @return the tree node to which the operation will be applied.
-     */
-    public TreeNode getApplyTo() {
-        return applyTo;
-    }
-
-    @Override
-    public String toString() {
-        return "(" + (applyTo == null ? "null" : applyTo.toString()) + ")" + operation;
-    }
-}

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/kotlin/org/nwapw/abacus/function/Documentation.kt

@@ -0,0 +1,26 @@
+package org.nwapw.abacus.function
+
+/**
+ * A data class used for storing information about a function.
+ *
+ * The Documentation class holds the information necessary to display the information
+ * about a function to the user.
+ *
+ * @param codeName the name of the function as it occurs in code.
+ * @param name the name of the function in English.
+ * @param description the short description of this function.
+ * @param longDescription the full description of this function.
+ * @param type the things this documentation maps to.
+ */
+data class Documentation(val codeName: String, val name: String,
+                         val description: String, val longDescription: String,
+                         val type: DocumentationType) {
+
+    fun matches(other: String): Boolean {
+        return codeName.toLowerCase().contains(other.toLowerCase()) ||
+                name.toLowerCase().contains(other.toLowerCase()) ||
+                description.toLowerCase().contains(other.toLowerCase()) ||
+                longDescription.toLowerCase().contains(other.toLowerCase())
+    }
+
+}

src/main/kotlin/org/nwapw/abacus/function/Operator.kt

@@ -0,0 +1,14 @@
+package org.nwapw.abacus.function
+
+/**
+ * A single operator that can be used by Abacus.
+ *
+ * This is a data class that holds the information about a single operator, such as a plus or minus.
+ *
+ * @param associativity the associativity of this operator, used for order of operations;.
+ * @param type the type of this operator, used for parsing (infix / prefix / postfix and binary / unary)
+ * @param precedence the precedence of this operator, used for order of operations.
+ * @param function the function this operator applies to its arguments.
+ */
+data class Operator(val associativity: OperatorAssociativity, val type: OperatorType,
+                    val precedence: Int, val function: Function)

src/main/kotlin/org/nwapw/abacus/tree/BinaryNode.kt

@@ -0,0 +1,26 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A tree node that holds a binary operation.
+ *
+ * This node represents any binary operation, such as binary infix or binary postfix. The only
+ * currently implemented into Abacus is binary infix, but that has more to do with the parser than
+ * this class, which doesn't care about the order that its operation and nodes were found in text.
+ *
+ * @param operation the operation this node performs on its children.
+ * @param left the left node.
+ * @param right the right node.
+ */
+data class BinaryNode(val operation: String, val left: TreeNode? = null, val right: TreeNode?) : TreeNode() {
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
+        val leftReduce = left?.reduce(reducer) ?: return null
+        val rightReduce = right?.reduce(reducer) ?: return null
+        return reducer.reduceNode(this, leftReduce, rightReduce)
+    }
+
+    override fun toString(): String {
+        return "(" + (left?.toString() ?: "null") + operation + (right?.toString() ?: "null") + ")"
+    }
+
+}

src/main/kotlin/org/nwapw/abacus/tree/FunctionNode.kt

@@ -0,0 +1,52 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A tree node that holds a function call.
+ *
+ * The function call node can hold any number of children, and passes the to the appropriate reducer,
+ * but that is its sole purpose.
+ *
+ * @param function the function string.
+ */
+data class FunctionNode(val function: String) : TreeNode() {
+
+    /**
+     * List of function parameters added to this node.
+     */
+    val children: MutableList<TreeNode> = mutableListOf()
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
+        val children = Array<Any?>(children.size, { children[it].reduce(reducer) ?: return null; })
+        return reducer.reduceNode(this, *children)
+    }
+
+    override fun toString(): String {
+        val buffer = StringBuffer()
+        buffer.append(function)
+        buffer.append('(')
+        for (i in 0 until children.size) {
+            buffer.append(children[i].toString())
+            buffer.append(if (i == children.size - 1) ")" else ",")
+        }
+        return buffer.toString()
+    }
+
+    /**
+     * Appends a child to this node's list of children.
+     *
+     * @node the node to append.
+     */
+    fun appendChild(node: TreeNode){
+        children.add(node)
+    }
+
+    /**
+     * Prepends a child to this node's list of children.
+     *
+     * @node the node to prepend.
+     */
+    fun prependChild(node: TreeNode){
+        children.add(0, node)
+    }
+
+}

src/main/kotlin/org/nwapw/abacus/tree/NumberNode.kt

@@ -0,0 +1,23 @@
+package org.nwapw.abacus.tree
+
+import org.nwapw.abacus.number.NumberInterface
+
+/**
+ * A tree node that holds a single number value.
+ *
+ * This is a tree node that holds a single NumberInterface, which represents any number,
+ * and is not defined during compile time.
+ *
+ * @number the number value of this node.
+ */
+data class NumberNode(val number: NumberInterface) : TreeNode() {
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
+        return reducer.reduceNode(this)
+    }
+
+    override fun toString(): String {
+        return number.toString()
+    }
+
+}

src/main/kotlin/org/nwapw/abacus/tree/TreeNode.kt

@@ -0,0 +1,10 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A tree node.
+ */
+abstract class TreeNode {
+
+    abstract fun <T: Any> reduce(reducer: Reducer<T>) : T?
+
+}

src/main/kotlin/org/nwapw/abacus/tree/UnaryNode.kt

@@ -0,0 +1,23 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A tree node that holds a unary operation.
+ *
+ * This node holds a single operator applied to a single parameter, and does not care
+ * whether the operation was found before or after the parameter in the text.
+ *
+ * @param operation the operation applied to the given node.
+ * @param applyTo the node to which the operation will be applied.
+ */
+data class UnaryNode(val operation: String, val applyTo: TreeNode? = null) : TreeNode() {
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
+        val reducedChild = applyTo?.reduce(reducer) ?: return null
+        return reducer.reduceNode(this, reducedChild)
+    }
+
+    override fun toString(): String {
+        return "(" + (applyTo?.toString() ?: "null") + ")" + operation
+    }
+
+}

src/main/resources/abacus.fxml

@@ -2,17 +2,14 @@
 
 <?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?>
-<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>
-            <Tab text="Calculator" closable="false">
+        <TabPane fx:id="coreTabPane">
+            <Tab fx:id="calculateTab" text="Calculator" closable="false">
                 <BorderPane>
                     <center>
                         <TableView fx:id="historyTable">
@@ -37,20 +34,41 @@
                             <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 text="Settings" closable="false">
+            <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"/>
-                    <Button fx:id="loadButton" text="Load" GridPane.rowIndex="1" GridPane.columnIndex="0" maxWidth = "Infinity" onAction="#loadClass"/>
-                    <Button fx:id="unloadButton" text="Unload" GridPane.rowIndex="1" GridPane.columnIndex="1" maxWidth = "Infinity" onAction="#unloadClass"/>
-                    <TextField fx:id="loadField" GridPane.rowIndex="1" GridPane.columnIndex="2"/>
+                    <ListView fx:id="enabledPluginView"
+                              GridPane.rowIndex="1" GridPane.columnIndex="0"
+                              GridPane.columnSpan="2" maxHeight="100"/>
+                    <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="functionListTab" text="Functions" closable="false">
+                <VBox spacing="10">
+                    <padding>
+                        <Insets left="10" right="10" top="10" bottom="10"/>
+                    </padding>
+                    <TextField fx:id="functionListSearchField" maxWidth="Infinity"/>
+                    <ListView maxWidth="Infinity" fx:id="functionListView"/>
+                </VBox>
+            </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[]{}));
+
+    @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[]{}));
     private static LexerTokenizer lexerTokenizer = new LexerTokenizer();
     private static Function subtractFunction = new Function() {
         @Override