Change precision to getMaxPrecision, as precision can be configured.

This prevents infinite loops, as Link nodes do not follow regular
addInto behavior.

.gitignore

@@ -20,3 +20,12 @@
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
+
+# Custom Stuff
+# Gradle
+.gradle/*
+build/*
+
+# IntelliJ
+.idea/*
+abacus.iml

build.gradle

@@ -0,0 +1,23 @@
+apply plugin: 'java'
+apply plugin: 'application'
+
+sourceSets {
+  main {
+    java {
+      srcDirs = ['src']
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+    compile 'com.moandjiezana.toml:toml4j:0.7.1'
+    testCompile 'junit:junit:4.12'
+}
+
+// Define the main class for the application
+mainClassName = 'org.nwapw.abacus.Abacus'
+

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Fri Jul 28 17:18:51 PDT 2017
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-bin.zip

gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save ( ) {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 'abacus'

src/org/nwapw/abacus/Abacus.java

@@ -1,10 +1,14 @@
 package org.nwapw.abacus;
 
 import org.nwapw.abacus.plugin.PluginManager;
+//import org.nwapw.abacus.plugin.StandardPlugin;
 import org.nwapw.abacus.plugin.StandardPlugin;
 import org.nwapw.abacus.window.Window;
+import org.nwapw.abacus.plugin.ClassFinder;
 
 import javax.swing.*;
+import java.io.IOException;
+import java.util.ArrayList;
 
 public class Abacus {
 
@@ -23,8 +27,16 @@ public class Abacus {
         }
         manager = new PluginManager();
         manager.addInstantiated(new StandardPlugin(manager));
+        try {
+            ClassFinder.loadJars("plugins")
+                    .forEach(plugin -> manager.addClass(plugin));
+        } catch (IOException | ClassNotFoundException e) {
+            e.printStackTrace();
+        }
         mainUi = new Window(manager);
         mainUi.setVisible(true);
+        manager.load();
+
     }
 
     public static void main(String[] args){

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

@@ -0,0 +1,18 @@
+package org.nwapw.abacus.config;
+
+/**
+ * Serializable class that will be used to load TOML
+ * configurations.
+ */
+public class Configuration {
+
+    /**
+     * The precision to which the calculator should operator.
+     */
+    public int decimalPrecision;
+    /**
+     * The type of number this calculator should use.
+     */
+    public String numberType;
+
+}

src/org/nwapw/abacus/config/ConfigurationObject.java

@@ -0,0 +1,146 @@
+package org.nwapw.abacus.config;
+
+import com.moandjiezana.toml.Toml;
+import com.moandjiezana.toml.TomlWriter;
+import org.nwapw.abacus.number.NaiveNumber;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A configuration object, which essentially
+ * manages saving, loading, and getting values
+ * from the configuration. While Configuration is
+ * the data model, this is the interface with it.
+ */
+public class ConfigurationObject {
+
+    /**
+     * The default implementation to use for instantiating numbers.
+     */
+    private static final Class<? extends NaiveNumber> DEFAULT_IMPLEMENTATION = NaiveNumber.class;
+    /**
+     * The writer used to store the configuration.
+     */
+    private static final TomlWriter TOML_WRITER = new TomlWriter();
+    /**
+     * The configuration instance being modeled.
+     */
+    private Configuration configuration;
+    /**
+     * A map of number names to their implementations, which
+     * will be provided by plugins.
+     */
+    private Map<String, Class<? extends NaiveNumber>> numberImplementations;
+
+    /**
+     * Sets up the ConfigurationObject.
+     * different constructors do different things,
+     * but they all lead here.
+     * @param configuration the configuration to set up with.
+     */
+    private void setup(Configuration configuration){
+        this.configuration = configuration;
+        numberImplementations = new HashMap<>();
+    }
+
+    /**
+     * Creates a default configuration.
+     * @return the newly created default configuration.
+     */
+    private Configuration getDefaultConfig(){
+        configuration = new Configuration();
+        configuration.decimalPrecision = -1;
+        configuration.numberType = "naive";
+        return configuration;
+    }
+
+    /**
+     * Register a number implementation.
+     * @param name the name of the number implementation to register the class as.
+     * @param newClass the class that will be used to instantiate the new number.
+     *                 It is required that this class provides a Number(String) constructor.
+     */
+    public void registerImplementation(String name, Class<? extends NaiveNumber> newClass){
+        numberImplementations.put(name, newClass);
+    }
+
+    /**
+     * Creates a new number with the configured type, passing
+     * it the given string.
+     * @param string the string from which the number should be parsed.
+     * @return the resulting number, or null if an error occurred.
+     */
+    public NaiveNumber numberFromString(String string)  {
+        Class<? extends NaiveNumber> toLoad =
+                numberImplementations.getOrDefault(configuration.numberType, DEFAULT_IMPLEMENTATION);
+        try {
+            return toLoad.getConstructor(String.class).newInstance(string);
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * Returns the configured, user-requested precision.
+     * @return the precision.
+     */
+    public int getPrecision(){
+        return configuration.decimalPrecision;
+    }
+
+    /**
+     * Saves the ConfigurationObject to the given file.
+     * @param toFile the file to save ot.
+     * @return true if the save succeed, false if otherwise.
+     */
+    public boolean save(File toFile){
+        if(toFile.getParentFile() != null) toFile.getParentFile().mkdirs();
+        try {
+            TOML_WRITER.write(configuration, toFile);
+            return true;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    /**
+     * Creates a new configuration object with the given config.
+     * @param config the config to use.
+     */
+    public ConfigurationObject(Configuration config){
+        setup(config);
+    }
+
+    /**
+     * Create a configuration object by attempting to
+     * load a config from the given path, using the
+     * default configuration otherwise.
+     * @param path the path to attempt to load.
+     */
+    public ConfigurationObject(File path){
+        Configuration config;
+        if(!path.exists()) {
+            config = getDefaultConfig();
+        } else {
+            Toml parse = new Toml();
+            parse.read(path);
+            config = parse.to(Configuration.class);
+        }
+        setup(config);
+    }
+
+    /**
+     * Creates a new configuration object with the
+     * default configuration.
+     */
+    public ConfigurationObject(){
+        setup(getDefaultConfig());
+    }
+
+}

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

@@ -2,6 +2,7 @@ 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;
 
@@ -17,6 +18,7 @@ public abstract class Function {
     private static final HashMap<Class<? extends NumberInterface>, Integer> priorityMap =
             new HashMap<Class<? extends NumberInterface>, Integer>() {{
                 put(NaiveNumber.class, 0);
+                put(PreciseNumber.class, 1);
             }};
 
     /**

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

@@ -0,0 +1,70 @@
+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/org/nwapw/abacus/function/OperatorAssociativity.java

@@ -1,4 +1,4 @@
-package org.nwapw.abacus.tree;
+package org.nwapw.abacus.function;
 
 /**
  * Enum to represent the associativity of an operator.

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

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

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

@@ -5,9 +5,7 @@ import org.nwapw.abacus.lexing.pattern.Match;
 import org.nwapw.abacus.lexing.pattern.Pattern;
 import org.nwapw.abacus.lexing.pattern.PatternNode;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Comparator;
-import java.util.HashSet;
 
 /**
  * A lexer that can generate tokens of a given type given a list of regular expressions
@@ -16,16 +14,53 @@ import java.util.HashSet;
  */
 public class Lexer<T> {
 
+    /**
+     * An entry that represents a pattern that has been registered with the lexer.
+     * @param <T> the type used to identify the pattern.
+     */
+    private static class PatternEntry<T>{
+        /**
+         * The name of the entry.
+         */
+        public String name;
+        /**
+         * The id of the entry.
+         */
+        public T id;
+
+        /**
+         * Creates a new pattern entry with the given name and id.
+         * @param name the name of the pattern entry.
+         * @param id the id of the pattern entry.
+         */
+        public PatternEntry(String name, T id){
+            this.name = name;
+            this.id = id;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(name, id);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            return obj instanceof PatternEntry &&
+                    ((PatternEntry) obj).name.equals(name) &&
+                    ((PatternEntry) obj).id.equals(id);
+        }
+    }
+
     /**
      * The registered patterns.
      */
-    private ArrayList<Pattern<T>> patterns;
+    private Map<PatternEntry<T>, Pattern<T>> patterns;
 
     /**
      * Creates a new lexer with no registered patterns.
      */
     public Lexer(){
-        patterns = new ArrayList<>();
+        patterns = new HashMap<>();
     }
 
     /**
@@ -35,7 +70,16 @@ public class Lexer<T> {
      */
     public void register(String pattern, T id){
         Pattern<T> compiledPattern = new Pattern<>(pattern, id);
-        if(compiledPattern.getHead() != null) patterns.add(compiledPattern);
+        if(compiledPattern.getHead() != null) patterns.put(new PatternEntry<>(pattern, id), compiledPattern);
+    }
+
+    /**
+     * Unregisters a pattern.
+     * @param pattern the pattern to unregister
+     * @param id the ID by which to identify the pattern.
+     */
+    public void unregister(String pattern, T id){
+        patterns.remove(new PatternEntry<>(pattern, id));
     }
 
     /**
@@ -50,7 +94,7 @@ public class Lexer<T> {
         HashSet<PatternNode<T>> currentSet = new HashSet<>();
         HashSet<PatternNode<T>> futureSet = new HashSet<>();
         int index = startAt;
-        for(Pattern<T> pattern : patterns){
+        for(Pattern<T> pattern : patterns.values()){
             pattern.getHead().addInto(currentSet);
         }
         while(!currentSet.isEmpty()){
@@ -83,7 +127,7 @@ public class Lexer<T> {
      * @param compare the comparator used to sort matches by their IDs.
      * @return the resulting list of matches, in order, or null on error.
      */
-    public ArrayList<Match<T>> lexAll(String from, int startAt, Comparator<T> compare){
+    public List<Match<T>> lexAll(String from, int startAt, Comparator<T> compare){
         int index = startAt;
         ArrayList<Match<T>> matches = new ArrayList<>();
         Match<T> lastMatch = null;

src/org/nwapw/abacus/lexing/pattern/LinkNode.java

@@ -11,7 +11,10 @@ public class LinkNode<T> extends PatternNode<T> {
 
     @Override
     public void addInto(Collection<PatternNode<T>> into) {
+        if(!into.contains(this)) {
+            into.add(this);
             addOutputsInto(into);
         }
+    }
 
 }

src/org/nwapw/abacus/lexing/pattern/Pattern.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.Map;
 import java.util.Stack;
 import java.util.function.Function;
 
@@ -32,7 +33,7 @@ public class Pattern<T> {
      * A map of regex operator to functions that modify a PatternChain
      * with the appropriate operation.
      */
-    private HashMap<Character, Function<PatternChain<T>, PatternChain<T>>> operations =
+    private Map<Character, Function<PatternChain<T>, PatternChain<T>>> operations =
             new HashMap<Character, Function<PatternChain<T>, PatternChain<T>>>() {{
                 put('+', Pattern.this::transformPlus);
                 put('*', Pattern.this::transformStar);
@@ -235,4 +236,22 @@ public class Pattern<T> {
     public PatternNode<T> getHead() {
         return head;
     }
+
+    /**
+     * Removes all characters that are considered "special" from
+     * the given string.
+     * @param from the string to sanitize.
+     * @return the resulting string.
+     */
+    public static String sanitize(String from){
+        Pattern<Integer> pattern = new Pattern<>("", 0);
+        from = from.replace(".", "\\.");
+        from = from.replace("|", "\\|");
+        from = from.replace("(", "\\(");
+        from = from.replace(")", "\\)");
+        for(Character key : pattern.operations.keySet()){
+            from = from.replace("" + key, "\\" + key);
+        }
+        return from;
+    }
 }

src/org/nwapw/abacus/lexing/pattern/PatternNode.java

@@ -3,6 +3,7 @@ package org.nwapw.abacus.lexing.pattern;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
+import java.util.Set;
 
 /**
  * A base class for a pattern node. Provides all functions
@@ -16,7 +17,7 @@ public class PatternNode<T> {
      * The set of states to which the lexer should continue
      * should this node be correctly matched.
      */
-    protected HashSet<PatternNode<T>> outputStates;
+    protected Set<PatternNode<T>> outputStates;
 
     /**
      * Creates a new pattern node.

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

@@ -10,6 +10,13 @@ public class NaiveNumber implements NumberInterface {
      */
     private double value;
 
+    /**
+     * Creates a new NaiveNumber with the given string.
+     * @param value the value, which will be parsed as a double.
+     */
+    public NaiveNumber(String value) {
+        this(Double.parseDouble(value));
+    }
     /**
      * Creates a new NaiveNumber with the given value.
      * @param value the value to use.
@@ -28,8 +35,8 @@ public class NaiveNumber implements NumberInterface {
     public static final NaiveNumber ONE = new NaiveNumber(1);
 
     @Override
-    public int precision() {
+    public int getMaxPrecision() {
-        return 15;
+        return 18;
     }
 
     @Override
@@ -88,11 +95,15 @@ public class NaiveNumber implements NumberInterface {
     @Override
     public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
         if(toClass == this.getClass()) return this;
+        else if(toClass == PreciseNumber.class){
+            return new PreciseNumber(Double.toString(value));
+        }
         return null;
     }
 
     public String toString(){
-        return Double.toString(value);
+        double shiftBy = Math.pow(10, 10);
+        return Double.toString(Math.round(value * shiftBy) / shiftBy);
     }
 
 }

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

@@ -6,10 +6,10 @@ package org.nwapw.abacus.number;
 public interface NumberInterface {
 
     /**
-     * The precision to which this number operates.
+     * The maximum precision to which this number operates.
      * @return the precision.
      */
-    int precision();
+    int getMaxPrecision();
 
     /**
      * Multiplies this number by another, returning
@@ -49,8 +49,8 @@ public interface NumberInterface {
 
     /**
      * Raises this number to an integer power.
-     * @param exponent
+     * @param exponent the exponent to which to take the number.
-     * @return
+     * @return the resulting value.
      */
     NumberInterface intPow(int exponent);
 

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

@@ -0,0 +1,113 @@
+package org.nwapw.abacus.number;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class PreciseNumber implements NumberInterface{
+
+    /**
+     * The number one.
+     */
+    static final PreciseNumber ONE = new PreciseNumber(BigDecimal.ONE);
+    /**
+     * The number zero.
+     */
+    static final PreciseNumber ZERO = new PreciseNumber(BigDecimal.ZERO);
+    /**
+     * The number ten.
+     */
+    static final PreciseNumber TEN = new PreciseNumber(BigDecimal.TEN);
+
+    /**
+     * The value of the PreciseNumber.
+     */
+    BigDecimal value;
+
+    /**
+     * Constructs a precise number from the given string.
+     * @param string a string representation of the number meeting the same conditions
+     *               as the BidDecimal(String) constructor.
+     */
+    public PreciseNumber(String string){
+        value = new BigDecimal(string);
+    }
+
+    /**
+     * Constructs a precise number from the given BigDecimal.
+     * @param value a BigDecimal object representing the value of the number.
+     */
+    public PreciseNumber(BigDecimal value){
+        this.value = value;
+    }
+
+    @Override
+    public int getMaxPrecision() {
+        return 54;
+    }
+
+    @Override
+    public NumberInterface multiply(NumberInterface multiplier) {
+        return new PreciseNumber(value.multiply(((PreciseNumber) multiplier).value));
+    }
+
+    @Override
+    public NumberInterface divide(NumberInterface divisor) {
+        return new PreciseNumber(value.divide(((PreciseNumber) divisor).value, this.getMaxPrecision(), RoundingMode.HALF_UP));
+    }
+
+    @Override
+    public NumberInterface add(NumberInterface summand) {
+        return new PreciseNumber(value.add(((PreciseNumber) summand).value));
+    }
+
+    @Override
+    public NumberInterface subtract(NumberInterface subtrahend) {
+        return new PreciseNumber(value.subtract(((PreciseNumber) subtrahend).value));
+    }
+
+    @Override
+    public NumberInterface intPow(int exponent) {
+        if(exponent == 0){
+            return PreciseNumber.ONE;
+        }
+        boolean takeReciprocal = exponent < 0;
+        exponent = Math.abs(exponent);
+        NumberInterface power = this;
+        for(int currentExponent = 1; currentExponent < exponent; currentExponent++){
+            power = power.multiply(this);
+        }
+        if(takeReciprocal){
+            power = PreciseNumber.ONE.divide(power);
+        }
+        return power;
+    }
+
+    @Override
+    public int compareTo(NumberInterface number) {
+        return value.compareTo(((PreciseNumber) number).value);
+    }
+
+    @Override
+    public int signum() {
+        return value.signum();
+    }
+
+    @Override
+    public NumberInterface negate(){
+        return new PreciseNumber(value.negate());
+    }
+
+    @Override
+    public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
+        if(toClass == this.getClass()){
+            return this;
+        }
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        BigDecimal rounded = value.setScale(getMaxPrecision() - 4, RoundingMode.HALF_UP);
+        return rounded.stripTrailingZeros().toPlainString();
+    }
+}

src/org/nwapw/abacus/plugin/ClassFinder.java

@@ -0,0 +1,76 @@
+package org.nwapw.abacus.plugin;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.stream.Collectors;
+
+/**
+ * Class that loads plugin classes from their jars.
+ */
+public class ClassFinder {
+
+    /**
+     * Loads all the plugin classes from the given plugin folder.
+     * @param filePath the path for the plugin folder.
+     * @return the list of all loaded classes.
+     * @throws IOException thrown if an error occurred scanning the plugin folder.
+     * @throws ClassNotFoundException thrown if the class listed in the file doesn't get loaded.
+     */
+    public static ArrayList<Class<?>> loadJars(String filePath) throws IOException, ClassNotFoundException {
+        return loadJars(new File(filePath));
+    }
+
+    /**
+     * Loads all the plugin classes from the given plugin folder.
+     * @param pluginFolderPath the folder in which to look for plugins.
+     * @return the list of all loaded classes.
+     * @throws IOException thrown if an error occurred scanning the plugin folder.
+     * @throws ClassNotFoundException thrown if the class listed in the file doesn't get loaded.
+     */
+    public static ArrayList<Class<?>> loadJars(File pluginFolderPath) throws IOException, ClassNotFoundException {
+        ArrayList<Class<?>> toReturn = new ArrayList<>();
+        if(!pluginFolderPath.exists()) return toReturn;
+        ArrayList<File> files = Files.walk(pluginFolderPath.toPath())
+                .map(Path::toFile)
+                .filter(f -> f.getName().endsWith(".jar"))
+                .collect(Collectors.toCollection(ArrayList::new));
+        for (File file : files){
+            toReturn.addAll(loadJar(file));
+        }
+        return toReturn;
+    }
+
+    /**
+     * Loads the classes from a single path, given by the file.
+     * @param jarLocation the location of the jar to load.
+     * @return the list of loaded classes loaded from the jar.
+     * @throws IOException thrown if there was an error reading the file
+     * @throws ClassNotFoundException thrown if the class could not be loaded.
+     */
+    public static ArrayList<Class<?>> loadJar(File jarLocation) throws IOException, ClassNotFoundException {
+        ArrayList<Class<?>> loadedClasses = new ArrayList<>();
+        String path = jarLocation.getPath();
+        URL[] urls = new URL[]{new URL("jar:file:" + path + "!/")};
+
+        URLClassLoader classLoader = URLClassLoader.newInstance(urls);
+        JarFile jarFolder = new JarFile(jarLocation);
+        Enumeration jarEntityList = jarFolder.entries();
+
+        while (jarEntityList.hasMoreElements()) {
+            JarEntry jarEntity = (JarEntry) jarEntityList.nextElement();
+            if (jarEntity.getName().endsWith(".class")) {
+                loadedClasses.add(classLoader.loadClass(jarEntity.getName().replace('/', '.').substring(0, jarEntity.getName().length() - 6)));
+            }
+        }
+        return loadedClasses;
+    }
+
+}

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

@@ -1,8 +1,11 @@
 package org.nwapw.abacus.plugin;
 
 import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.Operator;
 
 import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * A plugin class that can be externally implemented and loaded via the
@@ -16,12 +19,20 @@ public abstract class Plugin {
     /**
      * A hash map of functions mapped to their string names.
      */
-    private HashMap<String, Function> functions;
+    private Map<String, Function> functions;
+    /**
+     * A hash map of operators mapped to their string names.
+     */
+    private Map<String, Operator> operators;
     /**
      * The plugin manager in which to search for functions
      * not inside this package,
      */
     private PluginManager manager;
+    /**
+     * Whether this plugin has been loaded.
+     */
+    private boolean enabled;
 
     private Plugin(){ }
 
@@ -32,15 +43,24 @@ public abstract class Plugin {
     public Plugin(PluginManager manager) {
         this.manager = manager;
         functions = new HashMap<>();
+        operators = new HashMap<>();
+        enabled = false;
     }
 
     /**
-     * Determines whether the current plugin provides the given function name.
+     * Gets the list of functions provided by this plugin.
-     * @param functionName the name of the function provided.
+     * @return the list of registered functions.
-     * @return true of the function exists, false if it doesn't.
      */
-    public final boolean hasFunction(String functionName) {
+    public final Set<String> providedFunctions(){
-        return functions.containsKey(functionName);
+        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();
     }
 
     /**
@@ -52,37 +72,91 @@ public abstract class Plugin {
         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);
+    }
+
+    /**
+     * Enables the function, loading the necessary instances
+     * of functions.
+     */
+    public final void enable(){
+        if(enabled) return;
+        onEnable();
+        enabled = true;
+    }
+
+    /**
+     * Disables the plugin, clearing loaded data store by default
+     * and calling its disable() method.
+     */
+    public final void disable(){
+        if(!enabled) return;
+        onDisable();
+        functions.clear();
+        operators.clear();
+        enabled = false;
+    }
+
     /**
      * To be used in load(). Registers a function abstract class with the
      * plugin internally, which makes it accessible to the plugin manager.
      * @param name the name to register by.
      * @param toRegister the function implementation.
-     * @return true if the function was registered successfully, false if not.
      */
-    protected final boolean registerFunction(String name, Function toRegister) {
+    protected final void registerFunction(String name, Function toRegister) {
-        if(functionFor(name) == null){
         functions.put(name, toRegister);
-            return true;
     }
-        return false;
+
+    /**
+     * To be used in load(). Registers an operator abstract class
+     * with the plugin internally, which makes it accessible to
+     * the plugin manager.
+     * @param name the name of the operator.
+     * @param operator the operator to register.
+     */
+    protected final void registerOperator(String name, Operator operator) {
+        operators.put(name, operator);
     }
 
     /**
      * Searches the PluginManager for the given function name.
      * This can be used by the plugins internally in order to call functions
      * they do not provide.
-     * @param name then name for which to search
+     * @param name the name for which to search
      * @return the resulting function, or null if none was found for that name.
      */
     protected final Function functionFor(String name) {
         return manager.functionFor(name);
     }
 
+    /**
+     * Searches the PluginManager for the given operator name.
+     * This can be used by the plugins internally in order to call
+     * operations they do not provide.
+     * @param name the name for which to search
+     * @return the resulting operator, or null if none was found for that name.
+     */
+    protected final Operator operatorFor(String name) {
+        return manager.operatorFor(name);
+    }
+
     /**
      * Abstract method to be overridden by plugin implementation, in which the plugins
      * are supposed to register the functions they provide and do any other
      * necessary setup.
      */
-    public abstract void load();
+    public abstract void onEnable();
+
+    /**
+     * Abstract method overridden by the plugin implementation, in which the plugins
+     * are supposed to dispose of loaded functions, operators, and macros.
+     */
+    public abstract void onDisable();
 
 }

src/org/nwapw/abacus/plugin/PluginListener.java

@@ -0,0 +1,20 @@
+package org.nwapw.abacus.plugin;
+
+/**
+ * A listener that responds to changes in the PluginManager.
+ */
+public interface PluginListener {
+
+    /**
+     * Called when the PluginManager loads plugins.
+     * @param manager the manager that fired the event.
+     */
+    public void onLoad(PluginManager manager);
+
+    /**
+     * Called when the PluginManager unloads all its plugins.
+     * @param manager the manager that fired the event.
+     */
+    public void onUnload(PluginManager manager);
+
+}

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

@@ -1,10 +1,10 @@
 package org.nwapw.abacus.plugin;
 
 import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.Operator;
 
 import java.lang.reflect.InvocationTargetException;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashMap;
 
 /**
  * A class that controls instances of plugins, allowing for them
@@ -12,43 +12,96 @@ import java.util.HashMap;
  */
 public class PluginManager {
 
+    /**
+     * List of classes loaded by this manager.
+     */
+    private Set<Class<?>> loadedPluginClasses;
     /**
      * A list of loaded plugins.
      */
-    private ArrayList<Plugin> plugins;
+    private Set<Plugin> plugins;
     /**
      * List of functions that have been cached,
      * that is, found in a plugin and returned.
      */
-    private HashMap<String, Function> cachedFunctions;
+    private Map<String, Function> cachedFunctions;
+    /**
+     * List of operators tha have been cached,
+     * that is, found in a plugin and returned.
+     */
+    private Map<String, Operator> cachedOperators;
+    /**
+     * List of all functions loaded by the plugins.
+     */
+    private Set<String> allFunctions;
+    /**
+     * List of all operators loaded by the plugins.
+     */
+    private Set<String> allOperators;
+    /**
+     * The list of plugin listeners attached to this instance.
+     */
+    private Set<PluginListener> listeners;
 
     /**
      * Creates a new plugin manager.
      */
     public PluginManager(){
-        plugins = new ArrayList<>();
+        loadedPluginClasses = new HashSet<>();
+        plugins = new HashSet<>();
         cachedFunctions = new HashMap<>();
+        cachedOperators = new HashMap<>();
+        allFunctions = new HashSet<>();
+        allOperators = new HashSet<>();
+        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.
+     */
+    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);
+
+        T loadedValue = null;
+        for(Plugin plugin : plugins){
+            if(setFunction.apply(plugin).contains(name)){
+                loadedValue = getFunction.apply(plugin, name);
+                break;
+            }
+        }
+
+        cache.put(name, loadedValue);
+        return loadedValue;
+    }
     /**
      * Gets a function under the given name.
      * @param name the name of the function
      * @return the function under the given name.
      */
     public Function functionFor(String name){
-        if(cachedFunctions.containsKey(name)) {
+        return searchCached(plugins, cachedFunctions, Plugin::providedFunctions, Plugin::getFunction, name);
-            return cachedFunctions.get(name);
     }
 
-        Function loadedFunction = null;
+    /**
-        for(Plugin plugin : plugins){
+     * Gets an operator under the given name.
-            if(plugin.hasFunction(name)){
+     * @param name the name of the operator.
-                loadedFunction = plugin.getFunction(name);
+     * @return the operator under the given name.
-                break;
+     */
-            }
+    public Operator operatorFor(String name){
-        }
+        return searchCached(plugins, cachedOperators, Plugin::providedOperators, Plugin::getOperator, name);
-        cachedFunctions.put(name, loadedFunction);
-        return loadedFunction;
     }
 
     /**
@@ -56,9 +109,9 @@ public class PluginManager {
      * @param plugin the plugin to add.
      */
     public void addInstantiated(Plugin plugin){
-        plugin.load();
+        if(loadedPluginClasses.contains(plugin.getClass())) return;
-        cachedFunctions.clear();
         plugins.add(plugin);
+        loadedPluginClasses.add(plugin.getClass());
     }
 
     /**
@@ -67,7 +120,7 @@ public class PluginManager {
      * @param newClass the new class to instantiate.
      */
     public void addClass(Class<?> newClass){
-        if(!Plugin.class.isAssignableFrom(newClass)) return;
+        if(!Plugin.class.isAssignableFrom(newClass) || newClass == Plugin.class) return;
         try {
             addInstantiated((Plugin) newClass.getConstructor(PluginManager.class).newInstance(this));
         } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
@@ -75,4 +128,66 @@ public class PluginManager {
         }
     }
 
+    /**
+     * Loads all the plugins in the PluginManager.
+     */
+    public void load(){
+        for(Plugin plugin : plugins) plugin.enable();
+        for(Plugin plugin : plugins){
+            allFunctions.addAll(plugin.providedFunctions());
+            allOperators.addAll(plugin.providedOperators());
+        }
+        listeners.forEach(e -> e.onLoad(this));
+    }
+
+    /**
+     * Unloads all the plugins in the PluginManager.
+     */
+    public void unload(){
+        for(Plugin plugin : plugins) plugin.disable();
+        allFunctions.clear();
+        allOperators.clear();
+        listeners.forEach(e -> e.onUnload(this));
+    }
+
+    /**
+     * Reloads all the plugins in the PluginManager.
+     */
+    public void reload(){
+        unload();
+        reload();
+    }
+
+    /**
+     * Gets all the functions loaded by the Plugin Manager.
+     * @return the set of all functions that were loaded.
+     */
+    public Set<String> getAllFunctions() {
+        return allFunctions;
+    }
+
+    /**
+     * Gets all the operators loaded by the Plugin Manager.
+     * @return the set of all operators that were loaded.
+     */
+    public Set<String> getAllOperators() {
+        return allOperators;
+    }
+
+    /**
+     * Adds a plugin change listener to this plugin manager.
+     * @param listener the listener to add.
+     */
+    public void addListener(PluginListener listener){
+        listeners.add(listener);
+    }
+
+    /**
+     * Remove the plugin change listener from this plugin manager.
+     * @param listener the listener to remove.
+     */
+    public void removeListener(PluginListener listener){
+        listeners.remove(listener);
+    }
+    
 }

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

@@ -1,6 +1,9 @@
 package org.nwapw.abacus.plugin;
 
 import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 
@@ -17,8 +20,8 @@ public class StandardPlugin extends Plugin {
     }
 
     @Override
-    public void load() {
+    public void onEnable() {
-        registerFunction("+", new Function() {
+        registerOperator("+", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length >= 1;
@@ -32,9 +35,9 @@ public class StandardPlugin extends Plugin {
                 }
                 return sum;
             }
-        });
+        }));
 
-        registerFunction("-", new Function() {
+        registerOperator("-", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length == 2;
@@ -44,9 +47,9 @@ public class StandardPlugin extends Plugin {
             protected NumberInterface applyInternal(NumberInterface[] params) {
                 return params[0].subtract(params[1]);
             }
-        });
+        }));
 
-        registerFunction("*", new Function() {
+        registerOperator("*", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length >= 1;
@@ -60,9 +63,9 @@ public class StandardPlugin extends Plugin {
                 }
                 return product;
             }
-        });
+        }));
 
-        registerFunction("/", new Function() {
+        registerOperator("/", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length == 2;
@@ -72,9 +75,22 @@ public class StandardPlugin extends Plugin {
             protected NumberInterface applyInternal(NumberInterface[] params) {
                 return params[0].divide(params[1]);
             }
-        });
+        }));
 
-        registerFunction("!", new Function() {
+        registerOperator("^", 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 StandardPlugin.this.getFunction("exp").apply(StandardPlugin.this.getFunction("ln").apply(params[0]).multiply(params[1]));
+            }
+        }));
+
+        registerOperator("!", new Operator(OperatorAssociativity.RIGHT, OperatorType.UNARY_POSTFIX, 0, new Function() {
+            //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length == 1;
@@ -92,6 +108,23 @@ public class StandardPlugin extends Plugin {
                     factorial = factorial.multiply(multiplier);
                 }
                 return factorial;
+                /*if(!storedList.containsKey(params[0].getClass())){
+                    storedList.put(params[0].getClass(), new ArrayList<NumberInterface>());
+                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
+                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
+                }*/
+            }
+        }));
+
+        registerFunction("abs", new Function() {
+            @Override
+            protected boolean matchesParams(NumberInterface[] params) {
+                return params.length == 1;
+            }
+
+            @Override
+            protected NumberInterface applyInternal(NumberInterface[] params) {
+                return params[0].multiply((new NaiveNumber(params[0].signum())).promoteTo(params[0].getClass()));
             }
         });
 
@@ -103,19 +136,117 @@ public class StandardPlugin extends Plugin {
 
             @Override
             protected NumberInterface applyInternal(NumberInterface[] params) {
-                return sumSeries(params[0], StandardPlugin.this::getExpSeriesTerm, getNTermsExp(getMaxError(params[0]), params[0]));
+                boolean takeReciprocal = params[0].signum() == -1;
+                params[0] = StandardPlugin.this.getFunction("abs").apply(params[0]);
+                NumberInterface sum = sumSeries(params[0], StandardPlugin.this::getExpSeriesTerm, getNTermsExp(getMaxError(params[0]), params[0]));
+                if(takeReciprocal){
+                    sum = NaiveNumber.ONE.promoteTo(sum.getClass()).divide(sum);
+                }
+                return sum;
             }
         });
+
+        registerFunction("ln", new Function() {
+            @Override
+            protected boolean matchesParams(NumberInterface[] params) {
+                return params.length == 1;
+            }
+
+            @Override
+            protected NumberInterface applyInternal(NumberInterface[] params) {
+                NumberInterface param = params[0];
+                int powersOf2 = 0;
+                while(StandardPlugin.this.getFunction("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()));
+                        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()));
+                        powersOf2--;
+                        if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                            break;
+                            //No infinite loop for you.
+                        }
+                    }
+                }
+                return getLog2(param).multiply((new NaiveNumber(powersOf2)).promoteTo(param.getClass())).add(getLogPartialSum(param));
+            }
+
+            /**
+             * Returns the partial sum of the Taylor series for logx (around x=1).
+             * Automatically determines the number of terms needed based on the precision of x.
+             * @param x value at which the series is evaluated. 0 < x < 2. (x=2 is convergent but impractical.)
+             * @return the partial sum.
+             */
+            private NumberInterface getLogPartialSum(NumberInterface x){
+                NumberInterface maxError = StandardPlugin.this.getMaxError(x);
+                x = x.subtract(NaiveNumber.ONE.promoteTo(x.getClass())); //Terms used are for log(x+1).
+                NumberInterface currentTerm = x, sum = x;
+                int n = 1;
+                while(StandardPlugin.this.getFunction("abs").apply(currentTerm).compareTo(maxError) > 0){
+                    n++;
+                    currentTerm = currentTerm.multiply(x).multiply((new NaiveNumber(n-1)).promoteTo(x.getClass())).divide((new NaiveNumber(n)).promoteTo(x.getClass())).negate();
+                    sum = sum.add(currentTerm);
+                }
+                return sum;
+            }
+
+            /**
+             * Returns natural log of 2 to the required precision of the class of number.
+             * @param number a number of the same type as the return type. (Used for precision.)
+             * @return the value of log(2) with the appropriate precision.
+             */
+            private NumberInterface getLog2(NumberInterface number){
+                NumberInterface maxError = StandardPlugin.this.getMaxError(number);
+                //NumberInterface errorBound = (new NaiveNumber(1)).promoteTo(number.getClass());
+                //We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
+                //In the following, a=1/3^n, b=1/4^n, c = 1/n.
+                //a is also an error bound.
+                NumberInterface a = (new NaiveNumber(1)).promoteTo(number.getClass()), b = a, c = a;
+                NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClass());
+                int n = 0;
+                while(a.compareTo(maxError) >= 1){
+                    n++;
+                    a = a.divide((new NaiveNumber(3)).promoteTo(number.getClass()));
+                    b = b.divide((new NaiveNumber(4)).promoteTo(number.getClass()));
+                    c = NaiveNumber.ONE.promoteTo(number.getClass()).divide((new NaiveNumber(n)).promoteTo(number.getClass()));
+                    sum = sum.add(a.add(b).multiply(c));
+                }
+                return sum;
+            }
+        });
+
+        registerFunction("sqrt", new Function() {
+            @Override
+            protected boolean matchesParams(NumberInterface[] params) {
+                return params.length == 1;
+            }
+
+            @Override
+            protected NumberInterface applyInternal(NumberInterface[] params) {
+                return StandardPlugin.this.getOperator("^").getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
+            }
+        });
+    }
+
+    @Override
+    public void onDisable() {
+
     }
 
     /**
      * Returns the nth term of the Taylor series (centered at 0) of e^x
      * @param n the term required (n >= 0).
      * @param x the real number at which the series is evaluated.
-     * @return
+     * @return the nth term of the series.
      */
     private NumberInterface getExpSeriesTerm(int n, NumberInterface x){
-        return x.intPow(n).divide(this.getFunction("!").apply((new NaiveNumber(n)).promoteTo(x.getClass())));
+        return x.intPow(n).divide(this.getOperator("!").getFunction().apply((new NaiveNumber(n)).promoteTo(x.getClass())));
     }
 
     /**
@@ -123,17 +254,18 @@ public class StandardPlugin extends Plugin {
      * such that the error is at most maxError.
      * @param maxError Maximum error permissible (This should probably be positive.)
      * @param x where the function is evaluated.
-     * @return
+     * @return the number of terms needed to evaluated the exponential function.
      */
     private int getNTermsExp(NumberInterface maxError, NumberInterface x) {
-        //We need n such that x^(n+2) <= (n+1)! * maxError
+        //We need n such that |x^(n+1)| <= (n+1)! * maxError
         //The variables LHS and RHS refer to the above inequality.
         int n = 0;
-        NumberInterface LHS = x.intPow(2), RHS = maxError;
+        x = this.getFunction("abs").apply(x);
+        NumberInterface LHS = x, RHS = maxError;
         while (LHS.compareTo(RHS) > 0) {
             n++;
             LHS = LHS.multiply(x);
-            RHS = RHS.multiply(new NaiveNumber(n).promoteTo(RHS.getClass()));
+            RHS = RHS.multiply(new NaiveNumber(n + 1).promoteTo(RHS.getClass()));
         }
         return n;
     }
@@ -157,10 +289,10 @@ public class StandardPlugin extends Plugin {
     /**
      * Returns the maximum error based on the precision of the class of number.
      * @param number Any instance of the NumberInterface in question (should return an appropriate precision).
-     * @return
+     * @return the maximum error.
      */
     private NumberInterface getMaxError(NumberInterface number){
-        return (new NaiveNumber(10)).promoteTo(number.getClass()).intPow(-number.precision());
+        return (new NaiveNumber(10)).promoteTo(number.getClass()).intPow(-number.getMaxPrecision());
     }
 
 }

src/org/nwapw/abacus/tree/BinaryInfixNode.java

@@ -3,7 +3,7 @@ package org.nwapw.abacus.tree;
 /**
  * A tree node that represents an operation being applied to two operands.
  */
-public class OpNode extends TreeNode {
+public class BinaryInfixNode extends TreeNode {
 
     /**
      * The operation being applied.
@@ -18,14 +18,14 @@ public class OpNode extends TreeNode {
      */
     private TreeNode right;
 
-    private OpNode() {}
+    private BinaryInfixNode() {}
 
     /**
      * Creates a new operation node with the given operation
      * and no child nodes.
      * @param operation the operation.
      */
-    public OpNode(String operation){
+    public BinaryInfixNode(String operation){
         this(operation, null, null);
     }
 
@@ -36,7 +36,7 @@ public class OpNode extends TreeNode {
      * @param left the left node of the expression.
      * @param right the right node of the expression.
      */
-    public OpNode(String operation, TreeNode left, TreeNode right){
+    public BinaryInfixNode(String operation, TreeNode left, TreeNode right){
         this.operation = operation;
         this.left = left;
         this.right = right;
@@ -86,6 +86,7 @@ public class OpNode extends TreeNode {
     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);
     }
 
@@ -94,13 +95,6 @@ public class OpNode extends TreeNode {
         String leftString = left != null ? left.toString() : "null";
         String rightString = right != null ? right.toString() : "null";
 
-        if(right != null && right instanceof OpNode){
+        return "(" + leftString + operation + rightString + ")";
-            if(TreeNode.precedenceMap.get(((OpNode) right).getOperation()) >
-                    TreeNode.precedenceMap.get(operation)) {
-                rightString = "(" + rightString + ")";
-            }
-        }
-        
-        return leftString + operation + rightString;
     }
 }

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

@@ -0,0 +1,80 @@
+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/org/nwapw/abacus/tree/NumberNode.java

@@ -22,19 +22,10 @@ public class NumberNode extends TreeNode {
 
     /**
      * Creates a new number node with the given double value.
-     * @param value the value to use.
+     * @param newNumber the number for which to create a number node.
      */
-    public NumberNode(double value){
+    public NumberNode(NumberInterface newNumber){
-        number = new NaiveNumber(value);
+        this.number = newNumber;
-    }
-
-    /**
-     * Creates a new number node with the given string value, converted
-     * to a double.
-     * @param value the value.
-     */
-    public NumberNode(String value){
-        this(Double.parseDouble(value));
     }
 
     /**

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

@@ -1,12 +1,24 @@
 package org.nwapw.abacus.tree;
 
+import org.nwapw.abacus.function.Function;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.plugin.PluginManager;
 
+/**
+ * A reducer implementation that turns a tree into a single number.
+ * This is not always guaranteed to work.
+ */
 public class NumberReducer implements Reducer<NumberInterface> {
 
+    /**
+     * The plugin manager from which to draw the functions.
+     */
     private PluginManager manager;
 
+    /**
+     * Creates a new number reducer with the given plugin manager.
+     * @param manager the plugin manager.
+     */
     public NumberReducer(PluginManager manager){
         this.manager = manager;
     }
@@ -15,10 +27,25 @@ 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 OpNode){
+        } else if(node instanceof BinaryInfixNode){
             NumberInterface left = (NumberInterface) children[0];
             NumberInterface right = (NumberInterface) children[1];
-            return manager.functionFor(((OpNode) node).getOperation()).apply(left, right);
+            Function function = manager.operatorFor(((BinaryInfixNode) node).getOperation()).getFunction();
+            if(function == null) return null;
+            return function.apply(left, right);
+        } else if(node instanceof UnaryPrefixNode) {
+            NumberInterface child = (NumberInterface) children[0];
+            Function functionn = manager.operatorFor(((UnaryPrefixNode) node).getOperation()).getFunction();
+            if(functionn == null) return null;
+            return functionn.apply(child);
+        } else if(node instanceof FunctionNode){
+            NumberInterface[] convertedChildren = new NumberInterface[children.length];
+            for(int i = 0; i < convertedChildren.length; i++){
+                convertedChildren[i] = (NumberInterface) children[i];
+            }
+            Function function = manager.functionFor(((FunctionNode) node).getFunction());
+            if(function == null) return null;
+            return function.apply(convertedChildren);
         }
         return null;
     }

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

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

src/org/nwapw/abacus/tree/TreeBuilder.java

@@ -0,0 +1,207 @@
+package org.nwapw.abacus.tree;
+
+import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
+import org.nwapw.abacus.lexing.Lexer;
+import org.nwapw.abacus.lexing.pattern.Match;
+import org.nwapw.abacus.lexing.pattern.Pattern;
+import org.nwapw.abacus.number.NaiveNumber;
+import org.nwapw.abacus.number.PreciseNumber;
+
+import java.util.*;
+
+/**
+ * The builder responsible for turning strings into trees.
+ */
+public class TreeBuilder {
+
+    /**
+     * The lexer used to get the input tokens.
+     */
+    private Lexer<TokenType> lexer;
+    /**
+     * The map of operator precedences.
+     */
+    private Map<String, Integer> precedenceMap;
+    /**
+     * The map of operator associativity.
+     */
+    private Map<String, OperatorAssociativity> associativityMap;
+    /**
+     * The map of operator types.
+     */
+    private Map<String, OperatorType> typeMap;
+
+    /**
+     * Comparator used to sort token types.
+     */
+    protected static Comparator<TokenType> tokenSorter = Comparator.comparingInt(e -> e.priority);
+
+    /**
+     * Creates a new TreeBuilder.
+     */
+    public TreeBuilder(){
+        lexer = new Lexer<TokenType>(){{
+            register(" ", TokenType.WHITESPACE);
+            register(",", TokenType.COMMA);
+            register("[0-9]*(\\.[0-9]+)?", TokenType.NUM);
+            register("\\(", TokenType.OPEN_PARENTH);
+            register("\\)", TokenType.CLOSE_PARENTH);
+        }};
+        precedenceMap = new HashMap<>();
+        associativityMap = new HashMap<>();
+        typeMap = new HashMap<>();
+    }
+
+    /**
+     * Registers a function with the TreeBuilder.
+     * @param function the function to register.
+     */
+    public void registerFunction(String function){
+        lexer.register(Pattern.sanitize(function), TokenType.FUNCTION);
+    }
+
+    /**
+     * Registers an operator with the TreeBuilder.
+     * @param operator the operator to register.
+     * @param precedence the precedence of the operator.
+     * @param associativity the associativity of the operator.
+     */
+    public void registerOperator(String operator, OperatorAssociativity associativity,
+                                 OperatorType operatorType, int precedence){
+        lexer.register(Pattern.sanitize(operator), TokenType.OP);
+        precedenceMap.put(operator, precedence);
+        associativityMap.put(operator, associativity);
+        typeMap.put(operator, operatorType);
+    }
+
+    /**
+     * Tokenizes a string, converting it into matches
+     * @param string the string to tokenize.
+     * @return the list of tokens produced.
+     */
+    public List<Match<TokenType>> tokenize(String string){
+        return lexer.lexAll(string, 0, tokenSorter);
+    }
+
+    /**
+     * Rearranges tokens into a postfix list, using Shunting Yard.
+     * @param source the source string.
+     * @param from the tokens to be rearranged.
+     * @return the resulting list of rearranged tokens.
+     */
+    public List<Match<TokenType>> intoPostfix(String source, List<Match<TokenType>> from){
+        ArrayList<Match<TokenType>> output = new ArrayList<>();
+        Stack<Match<TokenType>> tokenStack = new Stack<>();
+        while(!from.isEmpty()){
+            Match<TokenType> match = from.remove(0);
+            TokenType matchType = match.getType();
+            if(matchType == TokenType.NUM) {
+                output.add(match);
+            } else if(matchType == TokenType.FUNCTION) {
+                output.add(new Match<>(0, 0, TokenType.INTERNAL_FUNCTION_END));
+                tokenStack.push(match);
+            } else if(matchType == TokenType.OP){
+                String tokenString = source.substring(match.getFrom(), match.getTo());
+                OperatorType type = typeMap.get(tokenString);
+                int precedence = precedenceMap.get(tokenString);
+                OperatorAssociativity associativity = associativityMap.get(tokenString);
+
+                if(type == OperatorType.UNARY_POSTFIX){
+                    output.add(match);
+                    continue;
+                }
+
+                while(!tokenStack.empty()) {
+                    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(source.substring(otherMatch.getFrom(), otherMatch.getTo()));
+                        if(otherPrecedence < precedence ||
+                                (associativity == OperatorAssociativity.RIGHT && otherPrecedence == precedence)) {
+                            break;
+                        }
+                    }
+                    output.add(tokenStack.pop());
+                }
+                tokenStack.push(match);
+            } else if(matchType == TokenType.OPEN_PARENTH){
+                tokenStack.push(match);
+            } else if(matchType == TokenType.CLOSE_PARENTH || matchType == TokenType.COMMA){
+                while(!tokenStack.empty() && tokenStack.peek().getType() != TokenType.OPEN_PARENTH){
+                    output.add(tokenStack.pop());
+                }
+                if(tokenStack.empty()) return null;
+                if(matchType == TokenType.CLOSE_PARENTH){
+                    tokenStack.pop();
+                }
+            }
+        }
+        while(!tokenStack.empty()){
+            Match<TokenType> match = tokenStack.peek();
+            TokenType matchType = match.getType();
+            if(!(matchType == TokenType.OP || matchType == TokenType.FUNCTION)) return null;
+            output.add(tokenStack.pop());
+        }
+        return output;
+    }
+
+    /**
+     * Constructs a tree recursively from a list of tokens.
+     * @param source the source string.
+     * @param matches the list of tokens from the source string.
+     * @return the construct tree expression.
+     */
+    public TreeNode fromStringRecursive(String source, List<Match<TokenType>> matches){
+        if(matches.size() == 0) return null;
+        Match<TokenType> match = matches.remove(0);
+        TokenType matchType = match.getType();
+        if(matchType == TokenType.OP){
+            String operator = source.substring(match.getFrom(), match.getTo());
+            OperatorType type = typeMap.get(operator);
+            if(type == OperatorType.BINARY_INFIX){
+                TreeNode right = fromStringRecursive(source, matches);
+                TreeNode left = fromStringRecursive(source, matches);
+                if(left == null || right == null) return null;
+                else return new BinaryInfixNode(operator, left, right);
+            } else {
+                TreeNode applyTo = fromStringRecursive(source, matches);
+                if(applyTo == null) return null;
+                else return new UnaryPrefixNode(operator, applyTo);
+            }
+        } else if(matchType == TokenType.NUM){
+            return new NumberNode(new NaiveNumber(Double.parseDouble(source.substring(match.getFrom(), match.getTo()))));
+        } else if(matchType == TokenType.FUNCTION){
+            String functionName = source.substring(match.getFrom(), match.getTo());
+            FunctionNode node = new FunctionNode(functionName);
+            while(!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END){
+                TreeNode argument = fromStringRecursive(source, matches);
+                if(argument == null) return null;
+                node.prependChild(argument);
+            }
+            if(matches.isEmpty()) return null;
+            matches.remove(0);
+            return node;
+        }
+        return null;
+    }
+
+    /**
+     * Creates a tree node from a string.
+     * @param string the string to create a node from.
+     * @return the resulting tree.
+     */
+    public TreeNode fromString(String string){
+        List<Match<TokenType>> matches = tokenize(string);
+        if(matches == null) return null;
+        matches.removeIf(m -> m.getType() == TokenType.WHITESPACE);
+        matches = intoPostfix(string, matches);
+        if(matches == null) return null;
+
+        Collections.reverse(matches);
+        return fromStringRecursive(string, matches);
+    }
+
+}

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

@@ -1,5 +1,6 @@
 package org.nwapw.abacus.tree;
 
+import org.nwapw.abacus.function.OperatorAssociativity;
 import org.nwapw.abacus.lexing.Lexer;
 import org.nwapw.abacus.lexing.pattern.Match;
 
@@ -11,133 +12,11 @@ import java.util.*;
 public abstract class TreeNode {
 
     /**
-     * The lexer used to lex tokens.
+     * 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.
      */
-    protected static Lexer<TokenType> lexer = new Lexer<TokenType>(){{
-        register("\\+|-|\\*|/|^", TokenType.OP);
-        register("[0-9]+(\\.[0-9]+)?", TokenType.NUM);
-        register("[a-zA-Z]+", TokenType.WORD);
-        register("\\(", TokenType.OPEN_PARENTH);
-        register("\\)", TokenType.CLOSE_PARENTH);
-    }};
-    /**
-     * A map that maps operations to their precedence.
-     */
-    protected static HashMap<String, Integer> precedenceMap = new HashMap<String, Integer>(){{
-        put("+", 0);
-        put("-", 0);
-        put("*", 1);
-        put("/", 1);
-        put("^", 2);
-    }};
-    /**
-     * A map that maps operations to their associativity.
-     */
-    protected static HashMap<String, OperatorAssociativity> associativityMap =
-            new HashMap<String, OperatorAssociativity>() {{
-                put("+", OperatorAssociativity.LEFT);
-                put("-", OperatorAssociativity.LEFT);
-                put("*", OperatorAssociativity.LEFT);
-                put("/", OperatorAssociativity.LEFT);
-                put("^", OperatorAssociativity.RIGHT);
-            }};
-
-    /**
-     * Comparator used to sort token types.
-     */
-    protected static Comparator<TokenType> tokenSorter = Comparator.comparingInt(e -> e.priority);
-
-    /**
-     * Tokenizes a string, converting it into matches
-     * @param string the string to tokenize.
-     * @return the list of tokens produced.
-     */
-    public static ArrayList<Match<TokenType>> tokenize(String string){
-        return lexer.lexAll(string, 0, tokenSorter);
-    }
-
-    /**
-     * Rearranges tokens into a postfix list, using Shunting Yard.
-     * @param source the source string.
-     * @param from the tokens to be rearranged.
-     * @return the resulting list of rearranged tokens.
-     */
-    public static ArrayList<Match<TokenType>> intoPostfix(String source, ArrayList<Match<TokenType>> from){
-        ArrayList<Match<TokenType>> output = new ArrayList<>();
-        Stack<Match<TokenType>> tokenStack = new Stack<>();
-        while(!from.isEmpty()){
-            Match<TokenType> match = from.remove(0);
-            if(match.getType() == TokenType.NUM) {
-                output.add(match);
-            } else if(match.getType() == TokenType.OP){
-                String tokenString = source.substring(match.getFrom(), match.getTo());
-                int precedence = precedenceMap.get(tokenString);
-                OperatorAssociativity associativity = associativityMap.get(tokenString);
-
-                while(!tokenStack.empty()) {
-                    Match<TokenType> otherMatch = tokenStack.peek();
-                    if(otherMatch.getType() != TokenType.OP) break;
-
-                    int otherPrecdence = precedenceMap.get(source.substring(otherMatch.getFrom(), otherMatch.getTo()));
-                    if(otherPrecdence < precedence ||
-                            (associativity == OperatorAssociativity.RIGHT && otherPrecdence == precedence)) {
-                        break;
-                    }
-                    output.add(tokenStack.pop());
-                }
-                tokenStack.push(match);
-            } else if(match.getType() == TokenType.OPEN_PARENTH){
-                tokenStack.push(match);
-            } else if(match.getType() == TokenType.CLOSE_PARENTH){
-                while(!tokenStack.empty() && tokenStack.peek().getType() != TokenType.OPEN_PARENTH){
-                    output.add(tokenStack.pop());
-                }
-                if(tokenStack.empty()) return null;
-                tokenStack.pop();
-            }
-        }
-        while(!tokenStack.empty()){
-            if(!(tokenStack.peek().getType() == TokenType.OP)) return null;
-            output.add(tokenStack.pop());
-        }
-        return output;
-    }
-
-    /**
-     * Constructs a tree recursively from a list of tokens.
-     * @param source the source string.
-     * @param matches the list of tokens from the source string.
-     * @return the construct tree expression.
-     */
-    public static TreeNode fromStringRecursive(String source, ArrayList<Match<TokenType>> matches){
-        if(matches.size() == 0) return null;
-        Match<TokenType> match = matches.remove(0);
-        if(match.getType() == TokenType.OP){
-            TreeNode right = fromStringRecursive(source, matches);
-            TreeNode left = fromStringRecursive(source, matches);
-            if(left == null || right == null) return null;
-            else return new OpNode(source.substring(match.getFrom(), match.getTo()), left, right);
-        } else if(match.getType() == TokenType.NUM){
-            return new NumberNode(Double.parseDouble(source.substring(match.getFrom(), match.getTo())));
-        }
-        return null;
-    }
-
-    /**
-     * Creates a tree node from a string.
-     * @param string the string to create a node from.
-     * @return the resulting tree.
-     */
-    public static TreeNode fromString(String string){
-        ArrayList<Match<TokenType>> matches = tokenize(string);
-        if(matches == null) return null;
-        matches = intoPostfix(string, matches);
-        if(matches == null) return null;
-
-        Collections.reverse(matches);
-        return fromStringRecursive(string, matches);
-    }
-
     public abstract <T> T reduce(Reducer<T> reducer);
 
 }

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

@@ -0,0 +1,59 @@
+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/org/nwapw/abacus/window/HistoryTableModel.java

@@ -6,21 +6,36 @@ import javax.swing.event.TableModelListener;
 import javax.swing.table.AbstractTableModel;
 import javax.swing.table.TableModel;
 import java.util.ArrayList;
+import java.util.List;
 
+/**
+ * A table model to store data about the history of inputs
+ * in the calculator.
+ */
 public class HistoryTableModel extends AbstractTableModel {
 
+    /**
+     * Static array used to get the column names.
+     */
     public static final String[] COLUMN_NAMES = {
             "Input",
             "Parsed Input",
             "Output"
     };
 
+    /**
+     * Static array used to get the class of each column.
+     */
     public static final Class[] CLASS_TYPES = {
             String.class,
             TreeNode.class,
             String.class
     };
 
+    /**
+     * Class used specifically to hold data about
+     * the previous entries into the calculator.
+     */
     public static class HistoryEntry {
         public String input;
         public TreeNode parsedInput;
@@ -40,12 +55,22 @@ public class HistoryTableModel extends AbstractTableModel {
         }
     }
 
-    ArrayList<HistoryEntry> entries;
+    /**
+     * The list of entries.
+     */
+    List<HistoryEntry> entries;
 
+    /**
+     * Creates a new empty history table model
+     */
     public HistoryTableModel() {
         entries = new ArrayList<>();
     }
 
+    /**
+     * Adds an entry to the model.
+     * @param entry the entry to add.
+     */
     public void addEntry(HistoryEntry entry){
         entries.add(entry);
     }
@@ -80,18 +105,4 @@ public class HistoryTableModel extends AbstractTableModel {
         return entries.get(rowIndex).nthValue(columnIndex);
     }
 
-    @Override
-    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
-        return;
-    }
-
-    @Override
-    public void addTableModelListener(TableModelListener l) {
-
-    }
-
-    @Override
-    public void removeTableModelListener(TableModelListener l) {
-
-    }
 }

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

@@ -1,7 +1,11 @@
 package org.nwapw.abacus.window;
 
+import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.plugin.PluginListener;
 import org.nwapw.abacus.plugin.PluginManager;
 import org.nwapw.abacus.tree.NumberReducer;
+import org.nwapw.abacus.tree.TreeBuilder;
 import org.nwapw.abacus.tree.TreeNode;
 
 import javax.swing.*;
@@ -14,20 +18,30 @@ import java.awt.event.MouseEvent;
 /**
  * The main UI window for the calculator.
  */
-public class Window extends JFrame {
+public class Window extends JFrame implements PluginListener {
 
     private static final String CALC_STRING = "Calculate";
-    private static final String SELECT_STRING = "Select";
     private static final String SYNTAX_ERR_STRING = "Syntax Error";
+    private static final String EVAL_ERR_STRING = "Evaluation Error";
     private static final String NUMBER_SYSTEM_LABEL = "Number Type:";
     private static final String FUNCTION_LABEL = "Functions:";
 
+    /**
+     * Array of Strings to which the "calculate" button's text
+     * changes. For instance, in the graph tab, the name will
+     * be "Graph" and not "Calculate".
+     */
     private static final String[] BUTTON_NAMES = {
             CALC_STRING,
             CALC_STRING
     };
 
-    private static boolean[] BUTTON_ENABLED = {
+    /**
+     * Array of booleans that determine whether the input
+     * field and the input button are enabled at a particular
+     * index.
+     */
+    private static boolean[] INPUT_ENABLED = {
             true,
             false
     };
@@ -36,6 +50,10 @@ public class Window extends JFrame {
      * The plugin manager used to retrieve functions.
      */
     private PluginManager manager;
+    /**
+     * The builder used to construct the parse trees.
+     */
+    private TreeBuilder builder;
     /**
      * The reducer used to evaluate the tree.
      */
@@ -112,18 +130,28 @@ public class Window extends JFrame {
      * Action listener that causes the input to be evaluated.
      */
     private ActionListener evaluateListener = (event) -> {
-        TreeNode parsedExpression = TreeNode.fromString(inputField.getText());
+        if(builder == null) return;
+        TreeNode parsedExpression = builder.fromString(inputField.getText());
         if(parsedExpression == null){
             lastOutputArea.setText(SYNTAX_ERR_STRING);
             return;
         }
-        lastOutput = parsedExpression.reduce(reducer).toString();
+        NumberInterface numberInterface = parsedExpression.reduce(reducer);
+        if(numberInterface == null){
+            lastOutputArea.setText(EVAL_ERR_STRING);;
+            return;
+        }
+        lastOutput = numberInterface.toString();
         historyModel.addEntry(new HistoryTableModel.HistoryEntry(inputField.getText(), parsedExpression, lastOutput));
         historyTable.invalidate();
         lastOutputArea.setText(lastOutput);
         inputField.setText("");
     };
 
+    /**
+     * Array of listeners that tell the input button how to behave
+     * at a given input tab.
+     */
     private ActionListener[] listeners = {
             evaluateListener,
             null
@@ -136,6 +164,7 @@ public class Window extends JFrame {
     public Window(PluginManager manager){
         this();
         this.manager = manager;
+        manager.addListener(this);
         reducer = new NumberReducer(manager);
     }
 
@@ -198,7 +227,7 @@ public class Window extends JFrame {
         pane.add("Settings", settingsPanel);
         pane.addChangeListener(e -> {
             int selectionIndex = pane.getSelectedIndex();
-            boolean enabled = BUTTON_ENABLED[selectionIndex];
+            boolean enabled = INPUT_ENABLED[selectionIndex];
             ActionListener listener = listeners[selectionIndex];
             inputEnterButton.setText(BUTTON_NAMES[selectionIndex]);
             inputField.setEnabled(enabled);
@@ -231,4 +260,24 @@ public class Window extends JFrame {
             }
         });
     }
+
+    @Override
+    public void onLoad(PluginManager manager) {
+        builder = new TreeBuilder();
+        for(String function : manager.getAllFunctions()){
+            builder.registerFunction(function);
+        }
+        for(String operator : manager.getAllOperators()){
+            Operator operatorObject = manager.operatorFor(operator);
+            builder.registerOperator(operator,
+                    operatorObject.getAssociativity(),
+                    operatorObject.getType(),
+                    operatorObject.getPrecedence());
+        }
+    }
+
+    @Override
+    public void onUnload(PluginManager manager) {
+        builder = null;
+    }
 }