Start implementing the canvas to draw graphs.

Replace some more cases where null is used with Exceptions.

.gitignore

@@ -24,7 +24,9 @@ hs_err_pid*
 # Custom Stuff
 # Gradle
 .gradle/*
-build/*
+**/build/*
+**/out/**
+**/.DS_Store
 
 # IntelliJ
 .idea/*

build.gradle

@@ -1,9 +1,25 @@
+buildscript {
+    ext.kotlin_version = '1.1.4-3'
+    ext.dokka_version = '0.9.15'
+
+    repositories {
+        jcenter()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
+    }
+}
+
 subprojects {
 
     apply plugin: 'java'
+    apply plugin: 'kotlin'
+    apply plugin: 'org.jetbrains.dokka'
 
     repositories {
-      mavenCentral()
+        jcenter()
     }
 
     dependencies {

core/build.gradle

@@ -1,8 +1,3 @@
-plugins {
-    id 'org.jetbrains.kotlin.jvm' version '1.1.3'
-}
-
 dependencies {
-    compile 'com.moandjiezana.toml:toml4j:0.7.1'
     testCompile 'junit:junit:4.12'
 }

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

@@ -1,135 +0,0 @@
-package org.nwapw.abacus;
-
-import org.nwapw.abacus.config.Configuration;
-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.NumberImplementation;
-import org.nwapw.abacus.plugin.PluginManager;
-import org.nwapw.abacus.plugin.StandardPlugin;
-import org.nwapw.abacus.tree.NumberReducer;
-import org.nwapw.abacus.tree.TreeNode;
-
-/**
- * The main calculator class. This is responsible
- * for piecing together all of the components, allowing
- * their interaction with each other.
- */
-public class Abacus {
-
-    /**
-     * The default number implementation to be used if no other one is available / selected.
-     */
-    public static final NumberImplementation DEFAULT_IMPLEMENTATION = StandardPlugin.IMPLEMENTATION_NAIVE;
-
-    /**
-     * The plugin manager responsible for
-     * loading and unloading plugins,
-     * and getting functions from them.
-     */
-    private PluginManager pluginManager;
-    /**
-     * The reducer used to evaluate the tree.
-     */
-    private NumberReducer numberReducer;
-    /**
-     * The configuration loaded from a file.
-     */
-    private Configuration configuration;
-    /**
-     * The tree builder used to construct a tree
-     * from a string.
-     */
-    private TreeBuilder treeBuilder;
-
-    /**
-     * Creates a new instance of the Abacus calculator.
-     *
-     * @param configuration the configuration object for this Abacus instance.
-     */
-    public Abacus(Configuration configuration) {
-        pluginManager = new PluginManager(this);
-        numberReducer = new NumberReducer(this);
-        this.configuration = new Configuration(configuration);
-        LexerTokenizer lexerTokenizer = new LexerTokenizer();
-        ShuntingYardParser shuntingYardParser = new ShuntingYardParser(this);
-        treeBuilder = new TreeBuilder<>(lexerTokenizer, shuntingYardParser);
-
-        pluginManager.addListener(shuntingYardParser);
-        pluginManager.addListener(lexerTokenizer);
-    }
-
-    /**
-     * Gets the current tree builder.
-     *
-     * @return the main tree builder in this abacus instance.
-     */
-    public TreeBuilder getTreeBuilder() {
-        return treeBuilder;
-    }
-
-    /**
-     * Gets the current plugin manager,
-     *
-     * @return the plugin manager in this abacus instance.
-     */
-    public PluginManager getPluginManager() {
-        return pluginManager;
-    }
-
-    /**
-     * Get the reducer that is responsible for transforming
-     * an expression into a number.
-     *
-     * @return the number reducer in this abacus instance.
-     */
-    public NumberReducer getNumberReducer() {
-        return numberReducer;
-    }
-
-    /**
-     * Gets the configuration object associated with this instance.
-     *
-     * @return the configuration object.
-     */
-    public Configuration getConfiguration() {
-        return configuration;
-    }
-
-    /**
-     * Parses a string into a tree structure using the main
-     * tree builder.
-     *
-     * @param input the input string to parse
-     * @return the resulting tree, null if the tree builder or the produced tree are null.
-     */
-    public TreeNode parseString(String input) {
-        return treeBuilder.fromString(input);
-    }
-
-    /**
-     * Evaluates the given tree using the main
-     * number reducer.
-     *
-     * @param tree the tree to reduce, must not be null.
-     * @return the resulting number, or null of the reduction failed.
-     */
-    public NumberInterface evaluateTree(TreeNode tree) {
-        return tree.reduce(numberReducer);
-    }
-
-    /**
-     * Creates a number from a string.
-     *
-     * @param numberString the string to create the number from.
-     * @return the resulting number.
-     */
-    public NumberInterface numberFromString(String numberString) {
-        NumberImplementation toInstantiate =
-                pluginManager.numberImplementationFor(configuration.getNumberImplementation());
-        if (toInstantiate == null) toInstantiate = DEFAULT_IMPLEMENTATION;
-
-        return toInstantiate.instanceForString(numberString);
-    }
-}

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

@@ -1,159 +0,0 @@
-package org.nwapw.abacus.config;
-
-import com.moandjiezana.toml.Toml;
-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
- * options that the user can change.
- */
-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 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 = "<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(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(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) {
-        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();
-        try {
-            TOML_WRITER.write(this, file);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    /**
-     * 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() {
-        return numberImplementation;
-    }
-
-    /**
-     * 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;
-    }
-
-}

core/src/main/java/org/nwapw/abacus/exception/AbacusException.java

@@ -0,0 +1,9 @@
+package org.nwapw.abacus.exception;
+
+public class AbacusException extends RuntimeException {
+
+    public AbacusException(String baseMessage, String description){
+        super(baseMessage + ((description.equals("")) ? "." : (": " + description)));
+    }
+
+}

core/src/main/java/org/nwapw/abacus/exception/ComputationInterruptedException.java

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

core/src/main/java/org/nwapw/abacus/exception/ContextException.java

@@ -0,0 +1,24 @@
+package org.nwapw.abacus.exception;
+
+/**
+ * Exception thrown by the Context in cases where lookup fails
+ * where it should not.
+ */
+public class ContextException extends AbacusException {
+
+    /**
+     * Creates a new ContextException without an extra message.
+     */
+    public ContextException() {
+        this("");
+    }
+
+    /**
+     * Creates a ContextException with the given message.
+     * @param message the message to use.
+     */
+    public ContextException(String message){
+        super("Context exception", message);
+    }
+
+}

core/src/main/java/org/nwapw/abacus/exception/DomainException.java

@@ -0,0 +1,24 @@
+package org.nwapw.abacus.exception;
+
+/**
+ * Exception thrown if the function parameters do not match
+ * requirements.
+ */
+public class DomainException extends AbacusException {
+
+    /**
+     * Creates a new DomainException.
+     * @param reason the reason for which the exception is thrown.
+     */
+    public DomainException(String reason) {
+        super("Domain error", reason);
+    }
+
+    /**
+     * Creates a new DomainException with a default message.
+     */
+    public DomainException(){
+        this("");
+    }
+
+}

core/src/main/java/org/nwapw/abacus/exception/NumberReducerException.java

@@ -0,0 +1,25 @@
+package org.nwapw.abacus.exception;
+
+/**
+ * Exception thrown by the NumberReducer if something goes wrong when
+ * transforming a parse tree into a single value.
+ */
+public class NumberReducerException extends AbacusException {
+
+    /**
+     * Creates a new NumberReducerException with
+     * no additional message.
+     */
+    public NumberReducerException() {
+        this("");
+    }
+
+    /**
+     * Creates a new NumberReducerException with the given message.
+     * @param message the message.
+     */
+    public NumberReducerException(String message) {
+        super("Error evaluating expression", message);
+    }
+
+}

core/src/main/java/org/nwapw/abacus/exception/ParseException.java

@@ -0,0 +1,23 @@
+package org.nwapw.abacus.exception;
+
+/**
+ * Exception thrown by parsers.
+ */
+public class ParseException extends AbacusException {
+
+    /**
+     * Creates a new ParseException with no additional message.
+     */
+    public ParseException(){
+        this("");
+    }
+
+    /**
+     * Creates a new ParseException with the given additional message.
+     * @param message the message.
+     */
+    public ParseException(String message){
+        super("Failed to parse string", message);
+    }
+
+}

core/src/main/java/org/nwapw/abacus/exception/PromotionException.java

@@ -0,0 +1,24 @@
+package org.nwapw.abacus.exception;
+
+/**
+ * Exception thrown when a promotion fails.
+ */
+public class PromotionException extends AbacusException {
+
+    /**
+     * Creates a new PromotionException with the default message
+     * and no additional information.
+     */
+    public PromotionException() {
+        this("");
+    }
+
+    /**
+     * Creates a new PromotionException with the given additional message.
+     * @param message the additional message to include with the error.
+     */
+    public PromotionException(String message) {
+        super("Failed to promote number instances", message);
+    }
+
+}

core/src/main/java/org/nwapw/abacus/exception/ReductionException.java

@@ -0,0 +1,23 @@
+package org.nwapw.abacus.exception;
+
+/**
+ * An exception thrown from TreeReducers.
+ */
+public class ReductionException extends AbacusException {
+
+    /**
+     * Creates a new EvaluationException with the default string.
+     */
+    public ReductionException() {
+        this("");
+    }
+
+    /**
+     * Creates a new EvaluationError with the given message string.
+     * @param message the message string.
+     */
+    public ReductionException(String message) {
+        super("Evaluation error", message);
+    }
+
+}

core/src/main/java/org/nwapw/abacus/exception/TokenizeException.java

@@ -0,0 +1,23 @@
+package org.nwapw.abacus.exception;
+
+/**
+ * Exception thrown by Lexers when they are unable to tokenize the input string.
+ */
+public class TokenizeException extends AbacusException {
+
+    /**
+     * Create a new tokenize exception with no additional data.
+     */
+    public TokenizeException() {
+        this("");
+    }
+
+    /**
+     * Create a new tokenize exception with the given message.
+     * @param message the message to use.
+     */
+    public TokenizeException(String message){
+        super("Failed to tokenize string", message);
+    }
+
+}

core/src/main/java/org/nwapw/abacus/function/DocumentationType.java

@@ -1,7 +1,11 @@
 package org.nwapw.abacus.function;
 
+/**
+ * Enum that holds the type of documentation that has been
+ * registered with Abacus.
+ */
 public enum DocumentationType {
 
-    FUNCTION
+    FUNCTION, TREE_VALUE_FUNCTION
 
 }

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

@@ -1,39 +0,0 @@
-package org.nwapw.abacus.function;
-
-import org.nwapw.abacus.number.NumberInterface;
-
-/**
- * A function that operates on one or more
- * inputs and returns a single number.
- */
-public abstract class Function {
-
-    /**
-     * Checks whether the given params will work for the given function.
-     *
-     * @param params the given params
-     * @return true if the params can be used with this function.
-     */
-    protected abstract boolean matchesParams(NumberInterface[] params);
-
-    /**
-     * Internal apply implementation, which already receives appropriately promoted
-     * parameters that have bee run through matchesParams
-     *
-     * @param params the promoted parameters.
-     * @return the return value of the function.
-     */
-    protected abstract NumberInterface applyInternal(NumberInterface[] params);
-
-    /**
-     * Function to check, promote arguments and run the function.
-     *
-     * @param params the raw input parameters.
-     * @return the return value of the function, or null if an error occurred.
-     */
-    public NumberInterface apply(NumberInterface... params) {
-        if (!matchesParams(params)) return null;
-        return applyInternal(params);
-    }
-
-}

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

@@ -1,16 +0,0 @@
-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.");
-    }
-
-}

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

@@ -114,22 +114,13 @@ public class NaiveNumber extends NumberInterface {
         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));
-        }
-        return null;
-    }
-
     public String toString() {
         double shiftBy = Math.pow(10, 10);
         return Double.toString(Math.round(value * shiftBy) / shiftBy);
     }
 
     @Override
-    public NumberInterface getMaxError(){
+    public NumberInterface getMaxError() {
         return new NaiveNumber(Math.pow(10, -18));
     }
 }

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

@@ -1,18 +1,21 @@
 package org.nwapw.abacus.number;
 
+import org.nwapw.abacus.exception.ComputationInterruptedException;
+
 /**
  * An interface used to represent a number.
  */
-public abstract class NumberInterface {
+public abstract class NumberInterface implements Comparable<NumberInterface> {
 
     /**
      * Check if the thread was interrupted and
      * throw an exception to end the computation.
      */
-    private static void checkInterrupted(){
-        if(Thread.currentThread().isInterrupted())
+    private static void checkInterrupted() {
+        if (Thread.currentThread().isInterrupted())
             throw new ComputationInterruptedException();
     }
+
     /**
      * The maximum precision to which this number operates.
      *
@@ -38,7 +41,7 @@ public abstract class NumberInterface {
      * @param multiplier the multiplier
      * @return the result of the multiplication.
      */
-    public final NumberInterface multiply(NumberInterface multiplier){
+    public final NumberInterface multiply(NumberInterface multiplier) {
         checkInterrupted();
         return multiplyInternal(multiplier);
     }
@@ -61,7 +64,7 @@ public abstract class NumberInterface {
      * @param divisor the divisor
      * @return the result of the division.
      */
-    public final NumberInterface divide(NumberInterface divisor){
+    public final NumberInterface divide(NumberInterface divisor) {
         checkInterrupted();
         return divideInternal(divisor);
     }
@@ -84,7 +87,7 @@ public abstract class NumberInterface {
      * @param summand the summand
      * @return the result of the summation.
      */
-    public final NumberInterface add(NumberInterface summand){
+    public final NumberInterface add(NumberInterface summand) {
         checkInterrupted();
         return addInternal(summand);
     }
@@ -107,7 +110,7 @@ public abstract class NumberInterface {
      * @param subtrahend the subtrahend.
      * @return the result of the subtraction.
      */
-    public final NumberInterface subtract(NumberInterface subtrahend){
+    public final NumberInterface subtract(NumberInterface subtrahend) {
         checkInterrupted();
         return subtractInternal(subtrahend);
     }
@@ -129,7 +132,7 @@ public abstract class NumberInterface {
      *
      * @return the new instance.
      */
-    public final NumberInterface negate(){
+    public final NumberInterface negate() {
         checkInterrupted();
         return negateInternal();
     }
@@ -150,19 +153,11 @@ public abstract class NumberInterface {
      * @param exponent the exponent to which to take the number.
      * @return the resulting value.
      */
-    public final NumberInterface intPow(int exponent){
+    public final NumberInterface intPow(int exponent) {
         checkInterrupted();
         return intPowInternal(exponent);
     }
 
-    /**
-     * Compares this number to another.
-     *
-     * @param number the number to compare to.
-     * @return same as Integer.compare();
-     */
-    public abstract int compareTo(NumberInterface number);
-
     /**
      * Same as Math.signum().
      *
@@ -184,7 +179,7 @@ public abstract class NumberInterface {
      *
      * @return the least integer bigger or equal to the number.
      */
-    public final NumberInterface ceiling(){
+    public final NumberInterface ceiling() {
         checkInterrupted();
         return ceilingInternal();
     }
@@ -203,7 +198,7 @@ public abstract class NumberInterface {
      *
      * @return the greatest int smaller than or equal to the number.
      */
-    public final NumberInterface floor(){
+    public final NumberInterface floor() {
         checkInterrupted();
         return floorInternal();
     }
@@ -219,9 +214,10 @@ public abstract class NumberInterface {
      * 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(){
+    public final NumberInterface fractionalPart() {
         checkInterrupted();
         return fractionalPartInternal();
     }
@@ -234,34 +230,24 @@ public abstract class NumberInterface {
      */
     public abstract int intValue();
 
-    /**
-     * Promotes this class to another number class.
-     *
-     * @param toClass the class to promote to.
-     * @return the resulting new instance.
-     */
-    @Deprecated
-    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.
-     */
-    @Deprecated
-    public final NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
-        checkInterrupted();
-        return promoteToInternal(toClass);
-    }
-
     /**
      * Returns the smallest error this instance can tolerate depending
      * on its precision and value.
+     *
      * @return the smallest error that should be permitted in calculations.
      */
     public abstract NumberInterface getMaxError();
 
+    /**
+     * Returns a NumberRangeBuilder object, which is used to create a range.
+     * The reason that this returns a builder and not an actual range is that
+     * the NumberRange needs to promote values passed to it, which
+     * requires an abacus instance.
+     * @param other the value at the bottom of the range.
+     * @return the resulting range builder.
+     */
+    public NumberRangeBuilder rangeTo(NumberInterface other){
+        return new NumberRangeBuilder(this, other);
+    }
+
 }

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

@@ -35,7 +35,7 @@ public class PreciseNumber extends NumberInterface {
     /**
      * MathContext that is actually used in calculations.
      */
-    private static MathContext internalContext = new MathContext(outputContext.getPrecision()+numExtraInternalSigFigs);
+    private static MathContext internalContext = new MathContext(outputContext.getPrecision() + numExtraInternalSigFigs);
 
     /**
      * The value of the PreciseNumber.
@@ -129,7 +129,7 @@ public class PreciseNumber extends NumberInterface {
         int decimalIndex = str.indexOf('.');
         if (decimalIndex != -1) {
             NumberInterface floor = new PreciseNumber(str.substring(0, decimalIndex));
-            if(signum() == -1){
+            if (signum() == -1) {
                 floor = floor.subtract(ONE);
             }
             return floor;
@@ -152,21 +152,13 @@ public class PreciseNumber extends NumberInterface {
         return new PreciseNumber(value.negate());
     }
 
-    @Override
-    public NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass) {
-        if (toClass == this.getClass()) {
-            return this;
-        }
-        return null;
-    }
-
     @Override
     public String toString() {
         return value.round(outputContext).toString();
     }
 
     @Override
-    public NumberInterface getMaxError(){
-        return new PreciseNumber(value.ulp()).multiplyInternal(TEN.intPowInternal(value.precision()-internalContext.getPrecision()));
+    public NumberInterface getMaxError() {
+        return new PreciseNumber(value.ulp()).multiplyInternal(TEN.intPowInternal(value.precision() - internalContext.getPrecision()));
     }
 }

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

@@ -1,5 +1,6 @@
 package org.nwapw.abacus.parsing;
 
+import org.nwapw.abacus.exception.TokenizeException;
 import org.nwapw.abacus.lexing.Lexer;
 import org.nwapw.abacus.lexing.pattern.Match;
 import org.nwapw.abacus.lexing.pattern.Pattern;
@@ -34,6 +35,7 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
             register(" ", TokenType.WHITESPACE);
             register(",", TokenType.COMMA);
             register("[0-9]*(\\.[0-9]+)?", TokenType.NUM);
+            register("[a-zA-Z]+", TokenType.VARIABLE);
             register("\\(", TokenType.OPEN_PARENTH);
             register("\\)", TokenType.CLOSE_PARENTH);
         }};
@@ -41,7 +43,9 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
 
     @Override
     public List<Match<TokenType>> tokenizeString(String string) {
-        return lexer.lexAll(string, 0, TOKEN_SORTER);
+        List<Match<TokenType>> tokens = lexer.lexAll(string, 0, TOKEN_SORTER);
+        if(tokens == null) throw new TokenizeException();
+        return tokens;
     }
 
     @Override
@@ -49,9 +53,15 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
         for (String operator : manager.getAllOperators()) {
             lexer.register(Pattern.sanitize(operator), TokenType.OP);
         }
+        for (String operator : manager.getAllTreeValueOperators()) {
+            lexer.register(Pattern.sanitize(operator), TokenType.TREE_VALUE_OP);
+        }
         for (String function : manager.getAllFunctions()) {
             lexer.register(Pattern.sanitize(function), TokenType.FUNCTION);
         }
+        for (String function : manager.getAllTreeValueFunctions()) {
+            lexer.register(Pattern.sanitize(function), TokenType.TREE_VALUE_FUNCTION);
+        }
     }
 
     @Override
@@ -59,9 +69,15 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
         for (String operator : manager.getAllOperators()) {
             lexer.unregister(Pattern.sanitize(operator), TokenType.OP);
         }
+        for (String operator : manager.getAllTreeValueOperators()) {
+            lexer.unregister(Pattern.sanitize(operator), TokenType.TREE_VALUE_OP);
+        }
         for (String function : manager.getAllFunctions()) {
             lexer.unregister(Pattern.sanitize(function), TokenType.FUNCTION);
         }
+        for (String function : manager.getAllTreeValueFunctions()) {
+            lexer.unregister(Pattern.sanitize(function), TokenType.TREE_VALUE_FUNCTION);
+        }
     }
 
 }

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

@@ -1,6 +1,6 @@
 package org.nwapw.abacus.parsing;
 
-import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.exception.ParseException;
 import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.function.OperatorAssociativity;
 import org.nwapw.abacus.function.OperatorType;
@@ -17,10 +17,6 @@ import java.util.*;
  */
 public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListener {
 
-    /**
-     * The Abacus instance used to create number instances.
-     */
-    private Abacus abacus;
     /**
      * Map of operator precedences, loaded from the plugin operators.
      */
@@ -35,12 +31,9 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
     private Map<String, OperatorType> typeMap;
 
     /**
-     * Creates a new Shunting Yard parser with the given Abacus instance.
-     *
-     * @param abacus the abacus instance.
+     * Creates a new Shunting Yard parser.
      */
-    public ShuntingYardParser(Abacus abacus) {
-        this.abacus = abacus;
+    public ShuntingYardParser() {
         precedenceMap = new HashMap<>();
         associativityMap = new HashMap<>();
         typeMap = new HashMap<>();
@@ -61,12 +54,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             Match<TokenType> match = from.remove(0);
             previousType = matchType;
             matchType = match.getType();
-            if (matchType == TokenType.NUM) {
+            if (matchType == TokenType.NUM || matchType == TokenType.VARIABLE) {
                 output.add(match);
-            } else if (matchType == TokenType.FUNCTION) {
+            } else if (matchType == TokenType.FUNCTION || matchType == TokenType.TREE_VALUE_FUNCTION) {
                 output.add(new Match<>("", TokenType.INTERNAL_FUNCTION_END));
                 tokenStack.push(match);
-            } else if (matchType == TokenType.OP) {
+            } else if (matchType == TokenType.OP || matchType == TokenType.TREE_VALUE_OP) {
                 String tokenString = match.getContent();
                 OperatorType type = typeMap.get(tokenString);
                 int precedence = precedenceMap.get(tokenString);
@@ -78,7 +71,7 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                 }
 
                 if (tokenString.equals("-") && (previousType == null || previousType == TokenType.OP ||
-                        previousType == TokenType.OPEN_PARENTH)) {
+                        previousType == TokenType.TREE_VALUE_OP || previousType == TokenType.OPEN_PARENTH)) {
                     from.add(0, new Match<>("`", TokenType.OP));
                     continue;
                 }
@@ -86,9 +79,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                 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 ||
+                            otherMatchType == TokenType.TREE_VALUE_OP ||
+                            otherMatchType == TokenType.FUNCTION ||
+                            otherMatchType == TokenType.TREE_VALUE_FUNCTION)) break;
 
-                    if (otherMatchType == TokenType.OP) {
+                    if (otherMatchType == TokenType.OP || otherMatchType == TokenType.TREE_VALUE_OP) {
                         int otherPrecedence = precedenceMap.get(otherMatch.getContent());
                         if (otherPrecedence < precedence ||
                                 (associativity == OperatorAssociativity.RIGHT && otherPrecedence == precedence)) {
@@ -104,7 +100,7 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                 while (!tokenStack.empty() && tokenStack.peek().getType() != TokenType.OPEN_PARENTH) {
                     output.add(tokenStack.pop());
                 }
-                if (tokenStack.empty()) return null;
+                if (tokenStack.empty()) throw new ParseException("mismatched parentheses");
                 if (matchType == TokenType.CLOSE_PARENTH) {
                     tokenStack.pop();
                 }
@@ -113,7 +109,10 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
         while (!tokenStack.empty()) {
             Match<TokenType> match = tokenStack.peek();
             TokenType newMatchType = match.getType();
-            if (!(newMatchType == TokenType.OP || newMatchType == TokenType.FUNCTION)) return null;
+            if (!(newMatchType == TokenType.OP ||
+                    newMatchType == TokenType.TREE_VALUE_OP ||
+                    newMatchType == TokenType.FUNCTION ||
+                    newMatchType == TokenType.TREE_VALUE_FUNCTION)) throw new ParseException("mismatched parentheses");
             output.add(tokenStack.pop());
         }
         return output;
@@ -126,46 +125,60 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
      * @return the construct tree expression.
      */
     public TreeNode constructRecursive(List<Match<TokenType>> matches) {
-        if (matches.size() == 0) return null;
+        if (matches.size() == 0) throw new ParseException("no tokens left in input");
         Match<TokenType> match = matches.remove(0);
         TokenType matchType = match.getType();
-        if (matchType == TokenType.OP) {
+        if (matchType == TokenType.OP || matchType == TokenType.TREE_VALUE_OP) {
             String operator = match.getContent();
             OperatorType type = typeMap.get(operator);
             if (type == OperatorType.BINARY_INFIX) {
                 TreeNode right = constructRecursive(matches);
                 TreeNode left = constructRecursive(matches);
-                if (left == null || right == null) return null;
-                else return new BinaryNode(operator, left, right);
+                if (matchType == TokenType.OP) {
+                    return new NumberBinaryNode(operator, left, right);
+                } else {
+                    return new TreeValueBinaryNode(operator, left, right);
+                }
             } else {
                 TreeNode applyTo = constructRecursive(matches);
-                if (applyTo == null) return null;
-                else return new UnaryNode(operator, applyTo);
+                if (matchType == TokenType.OP) {
+                    return new NumberUnaryNode(operator, applyTo);
+                } else {
+                    return new TreeValueUnaryNode(operator, applyTo);
+                }
             }
         } else if (matchType == TokenType.NUM) {
-            return new NumberNode(abacus.numberFromString(match.getContent()));
-        } else if (matchType == TokenType.FUNCTION) {
+            return new NumberNode(match.getContent());
+        } else if (matchType == TokenType.VARIABLE) {
+            return new VariableNode(match.getContent());
+        } else if (matchType == TokenType.FUNCTION || matchType == TokenType.TREE_VALUE_FUNCTION) {
             String functionName = match.getContent();
-            FunctionNode node = new FunctionNode(functionName);
+            List<TreeNode> children = new ArrayList<>();
             while (!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END) {
                 TreeNode argument = constructRecursive(matches);
-                if (argument == null) return null;
-                node.prependChild(argument);
+                children.add(0, argument);
             }
-            if (matches.isEmpty()) return null;
+            if (matches.isEmpty()) throw new ParseException("incorrectly formatted function call");
             matches.remove(0);
+            CallNode node;
+            if (matchType == TokenType.FUNCTION) {
+                node = new FunctionNode(functionName, children);
+            } else {
+                node = new TreeValueFunctionNode(functionName, children);
+            }
             return node;
         }
-        return null;
+        throw new ParseException("unrecognized token");
     }
 
     @Override
     public TreeNode constructTree(List<Match<TokenType>> tokens) {
+        if (tokens.isEmpty()) throw new ParseException("no input tokens");
         tokens = intoPostfix(new ArrayList<>(tokens));
-        if(tokens == null) return null;
         Collections.reverse(tokens);
         TreeNode constructedTree = constructRecursive(tokens);
-        return tokens.size() == 0 ? constructedTree : null;
+        if(tokens.size() == 0) return constructedTree;
+        throw new ParseException("could not parse all input");
     }
 
     @Override
@@ -176,6 +189,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             associativityMap.put(operator, operatorInstance.getAssociativity());
             typeMap.put(operator, operatorInstance.getType());
         }
+        for (String operator : manager.getAllTreeValueOperators()) {
+            Operator operatorInstance = manager.treeValueOperatorFor(operator);
+            precedenceMap.put(operator, operatorInstance.getPrecedence());
+            associativityMap.put(operator, operatorInstance.getAssociativity());
+            typeMap.put(operator, operatorInstance.getType());
+        }
     }
 
     @Override

core/src/main/java/org/nwapw/abacus/parsing/TreeBuilder.java

@@ -42,9 +42,7 @@ public class TreeBuilder<T> {
      * @return the resulting tree.
      */
     public TreeNode fromString(String input) {
-        List<T> tokens = tokenizer.tokenizeString(input);
-        if (tokens == null) return null;
-        return parser.constructTree(tokens);
+        return parser.constructTree(tokenizer.tokenizeString(input));
     }
 
 }

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

@@ -14,7 +14,7 @@ public abstract class NumberImplementation {
     /**
      * The list of paths through which this implementation can be promoted.
      */
-    private Map<Class<? extends NumberInterface>, Function<NumberInterface, NumberInterface>> promotionPaths;
+    private Map<String, Function<NumberInterface, NumberInterface>> promotionPaths;
     /**
      * The implementation class for this implementation.
      */
@@ -41,7 +41,7 @@ public abstract class NumberImplementation {
      *
      * @return the map of documentation paths.
      */
-    public final Map<Class<? extends NumberInterface>, Function<NumberInterface, NumberInterface>> getPromotionPaths() {
+    public final Map<String, Function<NumberInterface, NumberInterface>> getPromotionPaths() {
         return promotionPaths;
     }
 

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

@@ -1,15 +1,8 @@
 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.function.*;
 import org.nwapw.abacus.number.NumberInterface;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-
 /**
  * A plugin class that can be externally implemented and loaded via the
  * plugin manager. Plugins provide functionality to the calculator
@@ -69,10 +62,21 @@ public abstract class Plugin {
      * @param name       the name to register by.
      * @param toRegister the function implementation.
      */
-    protected final void registerFunction(String name, Function toRegister) {
+    protected final void registerFunction(String name, NumberFunction toRegister) {
         manager.registerFunction(name, toRegister);
     }
 
+    /**
+     * To be used in load(). Registers a tree value 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 tree value function implementation.
+     */
+    protected final void registerTreeValueFunction(String name, TreeValueFunction toRegister) {
+        manager.registerTreeValueFunction(name, toRegister);
+    }
+
     /**
      * To be used in load(). Registers an operator abstract class
      * with the plugin internally, which makes it accessible to
@@ -81,10 +85,22 @@ public abstract class Plugin {
      * @param name     the name of the operator.
      * @param operator the operator to register.
      */
-    protected final void registerOperator(String name, Operator operator) {
+    protected final void registerOperator(String name, NumberOperator operator) {
         manager.registerOperator(name, operator);
     }
 
+    /**
+     * To be used in load(). Registers an operator
+     * with the plugin internally, which makes it accessible
+     * to the plugin manager.
+     *
+     * @param name     the name of the tree value operator.
+     * @param operator the tree value operator to register.
+     */
+    protected final void registerTreeValueOperator(String name, TreeValueOperator operator) {
+        manager.registerTreeValueOperator(name, operator);
+    }
+
     /**
      * To be used in load(). Registers a new number implementation with the plugin.
      * This makes it accessible to the plugin manager.
@@ -99,9 +115,10 @@ public abstract class Plugin {
     /**
      * 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){
+    protected final void registerDocumentation(Documentation documentation) {
         manager.registerDocumentation(documentation);
     }
 
@@ -113,10 +130,22 @@ public abstract class Plugin {
      * @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) {
+    protected final NumberFunction functionFor(String name) {
         return manager.functionFor(name);
     }
 
+    /**
+     * 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 the name for which to search.
+     * @return the resulting tree value function, or null if none was found for that name.
+     */
+    protected final TreeValueFunction treeValueFunctionFor(String name) {
+        return manager.treeValueFunctionFor(name);
+    }
+
     /**
      * Searches the PluginManager for the given operator name.
      * This can be used by the plugins internally in order to call
@@ -125,10 +154,22 @@ public abstract class Plugin {
      * @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) {
+    protected final NumberOperator operatorFor(String name) {
         return manager.operatorFor(name);
     }
 
+    /**
+     * Searches the PluginManager for the given tree value 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 tree value operator, or null if none was found for that name.
+     */
+    protected final TreeValueOperator treeValueOperatorFor(String name) {
+        return manager.treeValueOperatorFor(name);
+    }
+
     /**
      * Searches the PluginManager for the given number implementation
      * name. This can be used by the plugins internally in order to find
@@ -148,7 +189,7 @@ public abstract class Plugin {
      * @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){
+    protected final Documentation documentationFor(String name, DocumentationType type) {
         return manager.documentationFor(name, type);
     }
 

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

@@ -1,14 +1,14 @@
 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.function.*;
 import org.nwapw.abacus.number.NumberInterface;
 
 import java.lang.reflect.InvocationTargetException;
-import java.util.*;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * A class that controls instances of plugins, allowing for them
@@ -27,11 +27,19 @@ public class PluginManager {
     /**
      * The map of functions registered by the plugins.
      */
-    private Map<String, Function> registeredFunctions;
+    private Map<String, NumberFunction> registeredFunctions;
+    /**
+     * The map of tree value functions regstered by the plugins.
+     */
+    private Map<String, TreeValueFunction> registeredTreeValueFunctions;
     /**
      * The map of operators registered by the plugins
      */
-    private Map<String, Operator> registeredOperators;
+    private Map<String, NumberOperator> registeredOperators;
+    /**
+     * The map of tree value operators registered by the plugins.
+     */
+    private Map<String, TreeValueOperator> registeredTreeValueOperators;
     /**
      * The map of number implementations registered by the plugins.
      */
@@ -41,10 +49,13 @@ public class PluginManager {
      */
     private Set<Documentation> registeredDocumentation;
     /**
-     * The list of number implementations that have been
-     * found by their implementation class.
+     * The list of number implementation names.
      */
-    private Map<Class<? extends NumberInterface>, NumberImplementation> cachedInterfaceImplementations;
+    private Map<Class<? extends NumberInterface>, String> interfaceImplementationNames;
+    /**
+     * The list of number implementations.
+     */
+    private Map<Class<? extends NumberInterface>, NumberImplementation> interfaceImplementations;
     /**
      * The pi values for each implementation class that have already been computer.
      */
@@ -69,95 +80,145 @@ public class PluginManager {
         loadedPluginClasses = new HashSet<>();
         plugins = new HashSet<>();
         registeredFunctions = new HashMap<>();
+        registeredTreeValueFunctions = new HashMap<>();
         registeredOperators = new HashMap<>();
+        registeredTreeValueOperators = new HashMap<>();
         registeredNumberImplementations = new HashMap<>();
         registeredDocumentation = new HashSet<>();
-        cachedInterfaceImplementations = new HashMap<>();
+        interfaceImplementations = new HashMap<>();
+        interfaceImplementationNames = new HashMap<>();
         cachedPi = new HashMap<>();
         listeners = new HashSet<>();
     }
 
     /**
      * Registers a function under the given name.
-     * @param name the name of the function.
+     *
+     * @param name     the name of the function.
      * @param function the function to register.
      */
-    public void registerFunction(String name, Function function){
+    public void registerFunction(String name, NumberFunction function) {
         registeredFunctions.put(name, function);
     }
 
+    /**
+     * Registers a tree value function under the given name.
+     *
+     * @param name     the name of the function.
+     * @param function the function to register.
+     */
+    public void registerTreeValueFunction(String name, TreeValueFunction function) {
+        registeredTreeValueFunctions.put(name, function);
+    }
+
     /**
      * Registers an operator under the given name.
-     * @param name the name of the operator.
+     *
+     * @param name     the name of the operator.
      * @param operator the operator to register.
      */
-    public void registerOperator(String name, Operator operator){
+    public void registerOperator(String name, NumberOperator operator) {
         registeredOperators.put(name, operator);
     }
 
+    /**
+     * Registers a tree value operator under the given name.
+     *
+     * @param name     the name of the tree value operator.
+     * @param operator the tree value operator to register.
+     */
+    public void registerTreeValueOperator(String name, TreeValueOperator operator) {
+        registeredTreeValueOperators.put(name, operator);
+    }
+
     /**
      * Registers a number implementation under the given name.
-     * @param name the name of the number implementation.
+     *
+     * @param name           the name of the number implementation.
      * @param implementation the number implementation to register.
      */
-    public void registerNumberImplementation(String name, NumberImplementation implementation){
+    public void registerNumberImplementation(String name, NumberImplementation implementation) {
         registeredNumberImplementations.put(name, implementation);
+        interfaceImplementationNames.put(implementation.getImplementation(), name);
+        interfaceImplementations.put(implementation.getImplementation(), implementation);
+        cachedPi.put(implementation.getImplementation(), implementation.instanceForPi());
     }
 
     /**
      * 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){
+    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){
+    public NumberFunction functionFor(String name) {
         return registeredFunctions.get(name);
     }
 
+    /**
+     * Gets the tree value function registered under the given name.
+     *
+     * @param name the name of the function.
+     * @return the function, or null if it was not found.
+     */
+    public TreeValueFunction treeValueFunctionFor(String name) {
+        return registeredTreeValueFunctions.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){
+    public NumberOperator operatorFor(String name) {
         return registeredOperators.get(name);
     }
 
+    /**
+     * Gets the tree value operator registered under the given name.
+     *
+     * @param name the name of the tree value operator.
+     * @return the operator, or null if it was not found.
+     */
+    public TreeValueOperator treeValueOperatorFor(String name) {
+        return registeredTreeValueOperators.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){
+    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){
+    public Documentation documentationFor(String name, DocumentationType type) {
         Documentation toReturn = null;
-        for(Documentation entry : registeredDocumentation){
-            if(entry.getCodeName().equals(name) && entry.getType() == type) {
+        for (Documentation entry : registeredDocumentation) {
+            if (entry.getCodeName().equals(name) && entry.getType() == type) {
                 toReturn = entry;
                 break;
             }
         }
-        if(toReturn == null){
-            toReturn = new Documentation(name, "", "", "", type);
-            registerDocumentation(toReturn);
-        }
         return toReturn;
     }
 
@@ -168,17 +229,17 @@ public class PluginManager {
      * @return the implementation.
      */
     public NumberImplementation interfaceImplementationFor(Class<? extends NumberInterface> name) {
-        if (cachedInterfaceImplementations.containsKey(name)) return cachedInterfaceImplementations.get(name);
-        NumberImplementation toReturn = null;
-        for(String key : registeredNumberImplementations.keySet()){
-            NumberImplementation implementation = registeredNumberImplementations.get(key);
-            if(implementation.getImplementation() == name) {
-                toReturn = implementation;
-                break;
-            }
-        }
-        cachedInterfaceImplementations.put(name, toReturn);
-        return toReturn;
+        return interfaceImplementations.get(name);
+    }
+
+    /**
+     * Gets the number implementation name for the given implementation class.
+     *
+     * @param name the class for which to find the implementation name.
+     * @return the implementation name.
+     */
+    public String interfaceImplementationNameFor(Class<? extends NumberInterface> name) {
+        return interfaceImplementationNames.get(name);
     }
 
     /**
@@ -188,14 +249,7 @@ public class PluginManager {
      * @return pi
      */
     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;
+        return cachedPi.get(forClass);
     }
 
     /**
@@ -226,10 +280,11 @@ public class PluginManager {
 
     /**
      * Removes the plugin with the given class from the manager.
+     *
      * @param toRemove the plugin to remove.
      */
-    public void removeClass(Class<? extends Plugin> toRemove){
-        if(!loadedPluginClasses.contains(toRemove)) return;
+    public void removeClass(Class<? extends Plugin> toRemove) {
+        if (!loadedPluginClasses.contains(toRemove)) return;
         plugins.removeIf(plugin -> plugin.getClass() == toRemove);
         loadedPluginClasses.remove(toRemove);
     }
@@ -237,7 +292,7 @@ public class PluginManager {
     /**
      * Removes all plugins from this plugin manager.
      */
-    public void removeAll(){
+    public void removeAll() {
         loadedPluginClasses.clear();
         plugins.clear();
     }
@@ -265,10 +320,13 @@ public class PluginManager {
             plugin.disable();
         }
         registeredFunctions.clear();
+        registeredTreeValueFunctions.clear();
         registeredOperators.clear();
+        registeredTreeValueOperators.clear();
         registeredNumberImplementations.clear();
         registeredDocumentation.clear();
-        cachedInterfaceImplementations.clear();
+        interfaceImplementationNames.clear();
+        interfaceImplementations.clear();
         cachedPi.clear();
         listeners.forEach(e -> e.onUnload(this));
     }
@@ -290,6 +348,15 @@ public class PluginManager {
         return registeredFunctions.keySet();
     }
 
+    /**
+     * Gets all the tree vlaue functions loaded by the PluginManager.
+     *
+     * @return the set of all the tree value functions that were loaded.
+     */
+    public Set<String> getAllTreeValueFunctions() {
+        return registeredTreeValueFunctions.keySet();
+    }
+
     /**
      * Gets all the operators loaded by the Plugin Manager.
      *
@@ -299,6 +366,15 @@ public class PluginManager {
         return registeredOperators.keySet();
     }
 
+    /**
+     * Gets all the tree value operators loaded by the PluginManager.
+     *
+     * @return the set of all tree value operators that were loaded.
+     */
+    public Set<String> getAllTreeValueOperators() {
+        return registeredTreeValueOperators.keySet();
+    }
+
     /**
      * Gets all the number implementations loaded by the Plugin Manager.
      *
@@ -335,4 +411,5 @@ public class PluginManager {
     public Set<Class<?>> getLoadedPluginClasses() {
         return loadedPluginClasses;
     }
+    
 }

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

@@ -1,54 +0,0 @@
-package org.nwapw.abacus.tree;
-
-import org.nwapw.abacus.Abacus;
-import org.nwapw.abacus.function.Function;
-import org.nwapw.abacus.number.NumberInterface;
-
-/**
- * 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 Abacus abacus;
-
-    /**
-     * Creates a new number reducer.
-     *
-     * @param abacus the calculator instance.
-     */
-    public NumberReducer(Abacus abacus) {
-        this.abacus = abacus;
-    }
-
-    @Override
-    public NumberInterface reduceNode(TreeNode node, Object... children) {
-        if (node instanceof NumberNode) {
-            return ((NumberNode) node).getNumber();
-        } else if (node instanceof BinaryNode) {
-            NumberInterface left = (NumberInterface) children[0];
-            NumberInterface right = (NumberInterface) children[1];
-            Function function = abacus.getPluginManager().operatorFor(((BinaryNode) node).getOperation()).getFunction();
-            if (function == null) return null;
-            return function.apply(left, right);
-        } else if (node instanceof UnaryNode) {
-            NumberInterface child = (NumberInterface) children[0];
-            Function functionn = abacus.getPluginManager().operatorFor(((UnaryNode) 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 = abacus.getPluginManager().functionFor(((FunctionNode) node).getFunction());
-            if (function == null) return null;
-            return function.apply(convertedChildren);
-        }
-        return null;
-    }
-
-}

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

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

core/src/main/kotlin/org/nwapw/abacus/Abacus.kt

@@ -0,0 +1,115 @@
+package org.nwapw.abacus
+
+import org.nwapw.abacus.config.Configuration
+import org.nwapw.abacus.context.MutableEvaluationContext
+import org.nwapw.abacus.context.EvaluationContext
+import org.nwapw.abacus.number.PromotionManager
+import org.nwapw.abacus.parsing.LexerTokenizer
+import org.nwapw.abacus.parsing.ShuntingYardParser
+import org.nwapw.abacus.parsing.TreeBuilder
+import org.nwapw.abacus.plugin.PluginManager
+import org.nwapw.abacus.plugin.StandardPlugin
+import org.nwapw.abacus.tree.EvaluationResult
+import org.nwapw.abacus.tree.NumberReducer
+import org.nwapw.abacus.tree.TreeNode
+
+/**
+ * Core class to handle all mathematics.
+ *
+ * The main calculator class. This is responsible
+ * for piecing together all of the components, allowing
+ * their interaction with each other.
+ *
+ * @property configuration the configuration to use.
+ */
+class Abacus(val configuration: Configuration) {
+
+    /**
+     * The tokenizer used to convert strings into tokens.
+     */
+    private val tokenizer = LexerTokenizer()
+    /**
+     * Parser the parser used to convert tokens into trees.
+     */
+    private val parser = ShuntingYardParser()
+    /**
+     * The plugin manager used to handle loading and unloading plugins.
+     */
+    val pluginManager = PluginManager(this)
+    /**
+     * The tree builder that handles the conversion of strings into trees.
+     */
+    val treeBuilder = TreeBuilder(tokenizer, parser)
+    /**
+     * The promotion manager used to convert between number implementations.
+     */
+    val promotionManager = PromotionManager(this)
+
+    /**
+     * The hidden, mutable implementation of the context.
+     */
+    private val mutableContext = MutableEvaluationContext(numberImplementation = StandardPlugin.IMPLEMENTATION_NAIVE)
+    /**
+     * The base context from which calculations are started.
+     */
+    val context: EvaluationContext
+        get() = mutableContext
+
+    init {
+        pluginManager.addListener(tokenizer)
+        pluginManager.addListener(parser)
+        pluginManager.addListener(promotionManager)
+    }
+
+    /**
+     * Reloads the Abacus core.
+     */
+    fun reload(){
+        pluginManager.reload()
+        with(mutableContext) {
+            numberImplementation = pluginManager.numberImplementationFor(configuration.numberImplementation)
+                    ?: StandardPlugin.IMPLEMENTATION_NAIVE
+            clearVariables()
+            clearDefinitions()
+        }
+    }
+    /**
+     * Merges the current context with the provided one, updating
+     * variables and the like.
+     * @param context the context to apply.
+     */
+    fun applyToContext(context: EvaluationContext){
+        mutableContext.apply(context)
+    }
+    /**
+     * Parses a string into a tree structure using the main
+     * tree builder.
+     *
+     * @param input the input string to parse
+     * @return the resulting tree, null if the tree builder or the produced tree are null.
+     */
+    fun parseString(input: String): TreeNode = treeBuilder.fromString(input)
+    /**
+     * Evaluates the given tree.
+     *
+     * @param tree the tree to reduce, must not be null.
+     * @return the evaluation result.
+     */
+    fun evaluateTree(tree: TreeNode): EvaluationResult {
+        return evaluateTreeWithContext(tree, context.mutableSubInstance())
+    }
+    /**
+     * Evaluates the given tree using a different context than
+     * the default one.
+     *
+     * @param tree the tree to reduce, must not be null.
+     * @param context the context to use for the evaluation.
+     * @return the evaluation result.
+     */
+    fun evaluateTreeWithContext(tree: TreeNode, context: MutableEvaluationContext): EvaluationResult {
+        val newReducer = NumberReducer(this, context)
+        val evaluationValue = tree.reduce(newReducer)
+        return EvaluationResult(evaluationValue, newReducer.context)
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/config/Configuration.kt

@@ -0,0 +1,20 @@
+package org.nwapw.abacus.config
+
+/**
+ * A class that holds information that tells Abacus how to behave.
+ *
+ * Configuration stores information about how Abacus should behave, for
+ * instance, what number implementation it should use and what
+ * plugins should be ignored during loading.
+ *
+ * @property numberImplementation the number implementation Abacus should use for loading.
+ * @param disabledPlugins the plugins that should be disabled and not loaded by the plugin manager.
+ */
+open class Configuration(var numberImplementation: String = "<default>", disabledPlugins: Array<String> = emptyArray()) {
+
+    /**
+     * The set of disabled plugins that should be ignored by the plugin manager.
+     */
+    val disabledPlugins = disabledPlugins.toMutableSet()
+
+}

core/src/main/kotlin/org/nwapw/abacus/context/ChainAccumulateDelegate.kt

@@ -0,0 +1,26 @@
+package org.nwapw.abacus.context
+
+import kotlin.reflect.KProperty
+
+/**
+ * A delegate to accumulate a collection of elements in a [EvaluationContext] hierarchy.
+ *
+ * ChainAccumulateDelegate is similar to the [ChainSearchDelegate], however, it operates only on collections.
+ * Instead of returning the most recent collection, it merges them into a [Set].
+ *
+ * @param T the type of element in the collection.
+ * @property valueGetter the getter used to access the collection from the context.
+ */
+class ChainAccumulateDelegate<out T>(private val valueGetter: EvaluationContext.() -> Collection<T>) {
+
+    operator fun getValue(selfRef: Any, property: KProperty<*>): Set<T> {
+        val set = mutableSetOf<T>()
+        var currentRef: EvaluationContext = selfRef as? EvaluationContext ?: return set
+        while(true) {
+            set.addAll(currentRef.valueGetter())
+            currentRef = currentRef.parent ?: break
+        }
+        return set
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/context/ChainSearchDelegate.kt

@@ -0,0 +1,30 @@
+package org.nwapw.abacus.context
+
+import org.nwapw.abacus.exception.ContextException
+import kotlin.reflect.KProperty
+
+/**
+ * A delegate to search a hierarchy made up of [EvaluationContext].
+ *
+ * ChainSearchDelegate is a variable delegate written specifically for use in [EvaluationContext], because
+ * of its hierarchical structure. Variables not found in the current context are searched
+ * for in its parent, which continues recursively until the context being examined has no parent.
+ * This class assists that logic, which is commonly re-used with different variable types, by calling
+ * [valueGetter] on the current context, then its parent, etc.
+ *
+ * @param V the type of the property to search recursively.
+ * @property valueGetter the getter lambda to access the value from the context.
+ */
+class ChainSearchDelegate<out V>(private val valueGetter: EvaluationContext.() -> V?) {
+
+    operator fun getValue(selfRef: Any, property: KProperty<*>): V {
+        var currentRef = selfRef as EvaluationContext
+        var returnedValue = currentRef.valueGetter()
+        while (returnedValue == null) {
+            currentRef = currentRef.parent ?: break
+            returnedValue = currentRef.valueGetter()
+        }
+        return returnedValue ?: throw ContextException("context chain does not contain value")
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/context/EvaluationContext.kt

@@ -0,0 +1,84 @@
+package org.nwapw.abacus.context
+
+import org.nwapw.abacus.number.NumberInterface
+import org.nwapw.abacus.plugin.NumberImplementation
+import org.nwapw.abacus.tree.Reducer
+import org.nwapw.abacus.tree.TreeNode
+
+/**
+ * A context for the reduction of a [org.nwapw.abacus.tree.TreeNode] into a number.
+ *
+ * The reduction context is used to carry important state information captured at the beginning
+ * of the reduction of an expression, such as the variables and the implementation in use.
+ *
+ * @property parent the parent of this context.
+ * @property numberImplementation the implementation for numbers of this context.
+ * @property reducer the reducer used by this context.
+ */
+open class EvaluationContext(val parent: EvaluationContext? = null,
+                             open val numberImplementation: NumberImplementation? = null,
+                             open val reducer: Reducer<NumberInterface>? = null) {
+
+    /**
+     * The map of variables in this context.
+     */
+    protected val variableMap = mutableMapOf<String, NumberInterface>()
+    /**
+     * The map of definitions in this context.
+     */
+    protected val definitionMap = mutableMapOf<String, TreeNode>()
+
+    /**
+     * The set of all variable names defined in this context.
+     */
+    val variables: Set<String>
+        get() = variableMap.keys
+
+    /**
+     * The set of all definition names defined in this context.
+     */
+    val definitions: Set<String>
+        get() = definitionMap.keys
+
+    /**
+     * The implementation inherited from this context's parent.
+     */
+    val inheritedNumberImplementation: NumberImplementation
+            by ChainSearchDelegate { numberImplementation }
+
+    /**
+     * The reducer inherited from this context's parent.
+     */
+    val inheritedReducer: Reducer<NumberInterface>
+            by ChainSearchDelegate { reducer }
+
+    /**
+     * The set of all variables in this context and its parents.
+     */
+    val inheritedVariables: Set<String> by ChainAccumulateDelegate { variables }
+
+    /**
+     * The set of all definition in this context and its parents.
+     */
+    val inheritedDefinitions: Set<String> by ChainAccumulateDelegate { definitions }
+
+    /**
+     * Create a new child instance of this context that is mutable.
+     * @return the new child instance.
+     */
+    fun mutableSubInstance(): MutableEvaluationContext = MutableEvaluationContext(this)
+
+    /**
+     * Gets a variable stored in this context.
+     */
+    fun getVariable(name: String): NumberInterface? {
+        return variableMap[name] ?: parent?.getVariable(name)
+    }
+    /**
+     * Gets the definition stored in this context.
+     */
+    fun getDefinition(name: String): TreeNode? {
+        return definitionMap[name] ?: parent?.getDefinition(name)
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/context/MutableEvaluationContext.kt

@@ -0,0 +1,69 @@
+package org.nwapw.abacus.context
+
+import org.nwapw.abacus.number.NumberInterface
+import org.nwapw.abacus.plugin.NumberImplementation
+import org.nwapw.abacus.tree.Reducer
+import org.nwapw.abacus.tree.TreeNode
+
+/**
+ * A reduction context that is mutable.
+ * @param parent the parent of this context.
+ * @param numberImplementation the number implementation used in this context.
+ * @param reducer the reducer used in this context
+ */
+class MutableEvaluationContext(parent: EvaluationContext? = null,
+                               numberImplementation: NumberImplementation? = null,
+                               reducer: Reducer<NumberInterface>? = null) :
+        EvaluationContext(parent, numberImplementation, reducer) {
+
+    override var numberImplementation: NumberImplementation? = super.numberImplementation
+    override var reducer: Reducer<NumberInterface>? = super.reducer
+
+    /**
+     * Writes data stored in the [other] context over data stored in this one.
+     * @param other the context from which to copy data.
+     */
+    fun apply(other: EvaluationContext) {
+        if(other.numberImplementation != null) numberImplementation = other.numberImplementation
+        if(other.reducer != null) reducer = other.reducer
+        for(name in other.variables) {
+            setVariable(name, other.getVariable(name) ?: continue)
+        }
+        for(name in other.definitions) {
+            setDefinition(name, other.getDefinition(name) ?: continue)
+        }
+    }
+
+    /**
+     * Sets a variable to a certain [value].
+     * @param name the name of the variable.
+     * @param value the value of the variable.
+     */
+    fun setVariable(name: String, value: NumberInterface) {
+        variableMap[name] = value
+    }
+
+    /**
+     * Set a definition to a certain [value].
+     * @param name the name of the definition.
+     * @param value the value of the definition.
+     */
+    fun setDefinition(name: String, value: TreeNode) {
+        definitionMap[name] = value
+    }
+
+    /**
+     * Clears the variables defined in this context.
+     */
+    fun clearVariables(){
+        variableMap.clear()
+    }
+
+    /**
+     * Clears the definitions defined in this context.
+     */
+    fun clearDefinitions(){
+        definitionMap.clear()
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/function/NumberFunction.kt

@@ -0,0 +1,12 @@
+package org.nwapw.abacus.function
+
+import org.nwapw.abacus.function.applicable.Applicable
+import org.nwapw.abacus.number.NumberInterface
+
+/**
+ * A function that operates on numbers.
+ *
+ * This function takes some number of input NumberInterfaces and returns
+ * another NumberInterface as a result.
+ */
+abstract class NumberFunction : Applicable<NumberInterface, NumberInterface>

core/src/main/kotlin/org/nwapw/abacus/function/NumberOperator.kt

@@ -0,0 +1,17 @@
+package org.nwapw.abacus.function
+
+import org.nwapw.abacus.function.applicable.Applicable
+import org.nwapw.abacus.number.NumberInterface
+
+/**
+ * An operator that operates on NumberImplementations.
+ *
+ * This is simply an alias for Operator<NumberInterface, NumberInterface>.
+ * @param associativity the associativity of the operator.
+ * @param type the type of the operator (binary, unary, etc)
+ * @param precedence the precedence of the operator.
+ */
+abstract class NumberOperator(associativity: OperatorAssociativity, type: OperatorType,
+                              precedence: Int) :
+        Operator(associativity, type, precedence),
+        Applicable<NumberInterface, NumberInterface>

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

@@ -3,12 +3,11 @@ 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.
+ * This is a 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)
+open class Operator(val associativity: OperatorAssociativity, val type: OperatorType,
+                    val precedence: Int)

core/src/main/kotlin/org/nwapw/abacus/function/TreeValueFunction.kt

@@ -0,0 +1,13 @@
+package org.nwapw.abacus.function
+
+import org.nwapw.abacus.function.applicable.Applicable
+import org.nwapw.abacus.number.NumberInterface
+import org.nwapw.abacus.tree.TreeNode
+
+/**
+ * A function that operates on trees.
+ *
+ * A function that operates on parse tree nodes instead of on already simplified numbers.
+ * Despite this, it returns a number, not a tree.
+ */
+abstract class TreeValueFunction : Applicable<TreeNode, NumberInterface>

core/src/main/kotlin/org/nwapw/abacus/function/TreeValueOperator.kt

@@ -0,0 +1,18 @@
+package org.nwapw.abacus.function
+
+import org.nwapw.abacus.function.applicable.Applicable
+import org.nwapw.abacus.number.NumberInterface
+import org.nwapw.abacus.tree.TreeNode
+
+/**
+ * An operator that operates on trees.
+ *
+ * This operator operates on parse trees, returning, however a number.
+ * @param associativity the associativity of the operator.
+ * @param type the type of the operator (infix, postfix, etc)
+ * @param precedence the precedence of the operator.
+ */
+abstract class TreeValueOperator(associativity: OperatorAssociativity, type: OperatorType,
+                                 precedence: Int) :
+        Operator(associativity, type, precedence),
+        Applicable<TreeNode, NumberInterface>

core/src/main/kotlin/org/nwapw/abacus/function/applicable/Applicable.kt

@@ -0,0 +1,44 @@
+package org.nwapw.abacus.function.applicable
+
+import org.nwapw.abacus.context.MutableEvaluationContext
+import org.nwapw.abacus.exception.DomainException
+
+/**
+ * A class that can be applied to arguments.
+ *
+ * Applicable is a class that represents something that can be applied to one or more
+ * arguments of the same type, and returns a single value from that application.
+ * @param <T> the type of the parameters passed to this applicable.
+ * @param <O> the return type of the applicable.
+ */
+interface Applicable<in T : Any, out O : Any> {
+
+    /**
+     * Checks if the given applicable can be used with the given parameters.
+     * @param params the parameter array to verify for compatibility.
+     * @return whether the array can be used with applyInternal.
+     */
+    fun matchesParams(context: MutableEvaluationContext, params: Array<out T>): Boolean
+
+    /**
+     * Applies the applicable object to the given parameters,
+     * without checking for compatibility.
+     * @param params the parameters to apply to.
+     * @return the result of the application.
+     */
+    fun applyInternal(context: MutableEvaluationContext, params: Array<out T>): O
+
+    /**
+     * If the parameters can be used with this applicable, returns
+     * the result of the application of the applicable to the parameters.
+     * Otherwise, returns null.
+     * @param params the parameters to apply to.
+     * @return the result of the operation, or null if parameters do not match.
+     */
+    fun apply(context: MutableEvaluationContext, vararg params: T): O {
+        if (!matchesParams(context, params))
+            throw DomainException("parameters do not match function requirements.")
+        return applyInternal(context, params)
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/number/NumberRange.kt

@@ -0,0 +1,28 @@
+package org.nwapw.abacus.number
+
+import org.nwapw.abacus.Abacus
+
+/**
+ * A closed range designed specifically for [NumberInterface]
+ *
+ * Besides providing the usual functionality of a [ClosedRange], this range
+ * also handles promotion - that is, it's safe to use it with numbers of different
+ * implementations, even as starting and ending points.
+ *
+ * @property abacus the abacus instance used for promotion.
+ * @property start the starting point of the range.
+ * @property endInclusive the ending point of the range.
+ */
+class NumberRange(val abacus: Abacus,
+                  override val start: NumberInterface,
+                  override val endInclusive: NumberInterface): ClosedRange<NumberInterface> {
+
+    override operator fun contains(value: NumberInterface): Boolean {
+        val promotionResult = abacus.promotionManager.promote(start, endInclusive, value)
+        val newStart = promotionResult.items[0]
+        val newEnd = promotionResult.items[1]
+        val newValue = promotionResult.items[2]
+        return newValue >= newStart && newValue <= newEnd
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/number/NumberRangeBuilder.kt

@@ -0,0 +1,24 @@
+package org.nwapw.abacus.number
+
+import org.nwapw.abacus.Abacus
+
+/**
+ * A utility class for creating [NumberRange] instances.
+ *
+ * Unlike a regular [ClosedRange], a NumberRange must have a third parameter,
+ * which is the [Abacus] instance that is used for promotion. However, the ".." operator
+ * is infix, and can only take two parameters. The solution is, instead of returning instances
+ * of NumberRange directly, to return a builder, which then provides a [with] infix function
+ * to attach it to an instance of Abacus.
+ * @property start the beginning of the range.
+ * @property endInclusive the end of the range.
+ */
+class NumberRangeBuilder(private val start: NumberInterface, private val endInclusive: NumberInterface) {
+
+    /**
+     * Generate a [NumberRange] with the given instance of [abacus].
+     * @return a new range with the given instance of Abacus.
+     */
+    infix fun with(abacus: Abacus) = NumberRange(abacus, start, endInclusive)
+
+}

core/src/main/kotlin/org/nwapw/abacus/number/NumberUtils.kt

@@ -0,0 +1,16 @@
+@file:JvmName("NumberUtils")
+package org.nwapw.abacus.number
+
+typealias PromotionFunction = java.util.function.Function<NumberInterface, NumberInterface>
+typealias PromotionPath = List<PromotionFunction>
+typealias NumberClass = Class<NumberInterface>
+
+/**
+ * Promote a number through this path. The functions in this path
+ * are applied in order to the number, and the final result is returned.
+ *
+ * @param from the number to start from.
+ */
+fun PromotionPath.promote(from: NumberInterface): NumberInterface {
+    return fold(from, { current, function -> function.apply(current) })
+}

core/src/main/kotlin/org/nwapw/abacus/number/PromotionManager.kt

@@ -0,0 +1,77 @@
+package org.nwapw.abacus.number
+
+import org.nwapw.abacus.Abacus
+import org.nwapw.abacus.exception.PromotionException
+import org.nwapw.abacus.plugin.NumberImplementation
+import org.nwapw.abacus.plugin.PluginListener
+import org.nwapw.abacus.plugin.PluginManager
+import java.util.function.Function
+
+/**
+ * A class that handles promotions based on priority and the
+ * transition paths each implementation provides.
+ *
+ * @property abacus the Abacus instance to use to access other components.
+ */
+class PromotionManager(val abacus: Abacus) : PluginListener {
+
+    /**
+     * The already computed paths
+     */
+    val computePaths = mutableMapOf<Pair<NumberImplementation, NumberImplementation>, PromotionPath?>()
+
+    /**
+     * Computes a path between a starting and an ending implementation.
+     *
+     * @param from the implementation to start from.
+     * @param to the implementation to get to.
+     * @return the resulting promotion path, or null if it is not found
+     */
+    fun computePathBetween(from: NumberImplementation, to: NumberImplementation): PromotionPath? {
+        val fromName = abacus.pluginManager.interfaceImplementationNameFor(from.implementation)
+        val toName = abacus.pluginManager.interfaceImplementationNameFor(to.implementation)
+
+        if(fromName == toName) return listOf(Function { it })
+
+        if(from.promotionPaths.containsKey(toName))
+            return listOf(from.promotionPaths[toName] ?: return null)
+        return null
+    }
+
+    /**
+     * Promote all the numbers in the list to the same number implementation, to ensure
+     * they can be used with each other. Finds the highest priority implementation
+     * in the list, and promotes all other numbers to it.
+     *
+     * @param numbers the numbers to promote.
+     * @return the resulting promotion result.
+     */
+    fun promote(vararg numbers: NumberInterface): PromotionResult {
+        val pluginManager = abacus.pluginManager
+        val implementations = numbers.map { pluginManager.interfaceImplementationFor(it.javaClass) }
+        val highestPriority = implementations.sortedBy { it.priority }.last()
+        return PromotionResult(items = numbers.map {
+            if(it.javaClass == highestPriority.implementation) it
+            else computePaths[pluginManager.interfaceImplementationFor(it.javaClass) to highestPriority]
+                    ?.promote(it) ?: throw PromotionException()
+        }.toTypedArray(), promotedTo = highestPriority)
+    }
+
+    override fun onLoad(manager: PluginManager) {
+        val implementations = manager.allNumberImplementations.map { manager.numberImplementationFor(it) }
+        for(first in implementations) {
+            for(second in implementations) {
+                val promoteFrom = if(second.priority > first.priority) first else second
+                val promoteTo = if(second.priority > first.priority) second else first
+                val path = computePathBetween(promoteFrom, promoteTo)
+                computePaths[promoteFrom to promoteTo] = path
+            }
+        }
+    }
+
+    override fun onUnload(manager: PluginManager) {
+        computePaths.clear()
+    }
+
+
+}

core/src/main/kotlin/org/nwapw/abacus/number/PromotionResult.kt

@@ -0,0 +1,11 @@
+package org.nwapw.abacus.number
+
+import org.nwapw.abacus.plugin.NumberImplementation
+
+/**
+ * The result of promoting an array of NumberInterfaces.
+ *
+ * @param promotedTo the implementation to which the numbers were promoted.
+ * @param items the items the items resulting from the promotion.
+ */
+data class PromotionResult(val promotedTo: NumberImplementation, val items: Array<NumberInterface>)

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

@@ -11,16 +11,10 @@ package org.nwapw.abacus.tree
  * @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)
-    }
+abstract class BinaryNode(val operation: String, val left: TreeNode, val right: TreeNode) : TreeNode() {
 
     override fun toString(): String {
-        return "(" + (left?.toString() ?: "null") + operation + (right?.toString() ?: "null") + ")"
+        return "(" + left.toString() + operation + right.toString() + ")"
     }
 
 }

core/src/main/kotlin/org/nwapw/abacus/tree/CallNode.kt

@@ -0,0 +1,25 @@
+package org.nwapw.abacus.tree
+
+/**
+ * Represents a more generic function call.
+ *
+ * This class does not specify how it should be reduced, allowing other classes
+ * to extend this functionality.
+ *
+ * @param callTo the name of the things being called.
+ * @param children the children of this node.
+ */
+abstract class CallNode(val callTo: String, val children: List<TreeNode>) : TreeNode() {
+
+    override fun toString(): String {
+        val buffer = StringBuffer()
+        buffer.append(callTo)
+        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()
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/tree/EvaluationResult.kt

@@ -0,0 +1,6 @@
+package org.nwapw.abacus.tree
+
+import org.nwapw.abacus.context.MutableEvaluationContext
+import org.nwapw.abacus.number.NumberInterface
+
+data class EvaluationResult(val value: NumberInterface, val resultingContext: MutableEvaluationContext)

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

@@ -8,45 +8,11 @@ package org.nwapw.abacus.tree
  *
  * @param function the function string.
  */
-data class FunctionNode(val function: String) : TreeNode() {
+class FunctionNode(function: String, children: List<TreeNode>) : CallNode(function, children) {
 
-    /**
-     * 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; })
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
+        val children = Array<Any>(children.size, { children[it].reduce(reducer) })
         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)
-    }
-
 }

core/src/main/kotlin/org/nwapw/abacus/tree/NumberBinaryNode.kt

@@ -0,0 +1,22 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A binary operator node that reduces its children.
+ *
+ * NumberBinaryNode operates by simply reducing its children and
+ * then using the result of that reduction to reduce itself.
+ *
+ * @param operation the operation this node performs.
+ * @param left the left child of this node.
+ * @param right the right child of this node.
+ */
+class NumberBinaryNode(operation: String, left: TreeNode, right: TreeNode)
+    : BinaryNode(operation, left, right) {
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
+        val left = left.reduce(reducer)
+        val right = right.reduce(reducer)
+        return reducer.reduceNode(this, left, right)
+    }
+
+}

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

@@ -1,7 +1,5 @@
 package org.nwapw.abacus.tree
 
-import org.nwapw.abacus.number.NumberInterface
-
 /**
  * A tree node that holds a single number value.
  *
@@ -10,14 +8,14 @@ import org.nwapw.abacus.number.NumberInterface
  *
  * @number the number value of this node.
  */
-data class NumberNode(val number: NumberInterface) : TreeNode() {
+class NumberNode(val number: String) : TreeNode() {
 
-    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
         return reducer.reduceNode(this)
     }
 
     override fun toString(): String {
-        return number.toString()
+        return number
     }
 
 }

core/src/main/kotlin/org/nwapw/abacus/tree/NumberReducer.kt

@@ -0,0 +1,65 @@
+package org.nwapw.abacus.tree
+
+import org.nwapw.abacus.Abacus
+import org.nwapw.abacus.context.EvaluationContext
+import org.nwapw.abacus.exception.NumberReducerException
+import org.nwapw.abacus.exception.ReductionException
+import org.nwapw.abacus.number.NumberInterface
+
+class NumberReducer(val abacus: Abacus, context: EvaluationContext) : Reducer<NumberInterface> {
+
+    val context = context.mutableSubInstance()
+
+    init {
+        this.context.reducer = this
+    }
+
+    override fun reduceNode(treeNode: TreeNode, vararg children: Any): NumberInterface {
+        val promotionManager = abacus.promotionManager
+        return when(treeNode){
+            is NumberNode -> {
+                context.inheritedNumberImplementation.instanceForString(treeNode.number)
+            }
+            is VariableNode -> {
+                val variable = context.getVariable(treeNode.variable)
+                if(variable != null) return variable
+                val definition = context.getDefinition(treeNode.variable)
+                if(definition != null) return definition.reduce(this)
+                throw NumberReducerException("variable is not defined.")
+            }
+            is NumberUnaryNode -> {
+                val child = children[0] as NumberInterface
+                context.numberImplementation = abacus.pluginManager.interfaceImplementationFor(child.javaClass)
+                abacus.pluginManager.operatorFor(treeNode.operation)
+                        .apply(context, child)
+            }
+            is NumberBinaryNode -> {
+                val left = children[0] as NumberInterface
+                val right = children[1] as NumberInterface
+                val promotionResult = promotionManager.promote(left, right)
+                context.numberImplementation = promotionResult.promotedTo
+                abacus.pluginManager.operatorFor(treeNode.operation).apply(context, *promotionResult.items)
+            }
+            is FunctionNode -> {
+                val promotionResult = promotionManager
+                        .promote(*children.map { it as NumberInterface }.toTypedArray())
+                context.numberImplementation = promotionResult.promotedTo
+                abacus.pluginManager.functionFor(treeNode.callTo).apply(context, *promotionResult.items)
+            }
+            is TreeValueUnaryNode -> {
+                abacus.pluginManager.treeValueOperatorFor(treeNode.operation)
+                        .apply(context, treeNode.applyTo)
+            }
+            is TreeValueBinaryNode -> {
+                abacus.pluginManager.treeValueOperatorFor(treeNode.operation)
+                        .apply(context, treeNode.left, treeNode.right)
+            }
+            is TreeValueFunctionNode -> {
+                abacus.pluginManager.treeValueFunctionFor(treeNode.callTo)
+                        .apply(context, *treeNode.children.toTypedArray())
+            }
+            else -> throw ReductionException("unrecognized tree node.")
+        }
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/tree/NumberUnaryNode.kt

@@ -0,0 +1,19 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A unary operator node that reduces its children.
+ *
+ * NumberUnaryNode operates by simply reducing its child,
+ * and using the result of that reduction to reduce itself.
+ * @param operation the operation this node performs.
+ * @param child the child this node should be applied to.
+ */
+class NumberUnaryNode(operation: String, child: TreeNode)
+    : UnaryNode(operation, child) {
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
+        val child = applyTo.reduce(reducer)
+        return reducer.reduceNode(this, child)
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/tree/Reducer.kt

@@ -6,7 +6,7 @@ package org.nwapw.abacus.tree
  * The reducer walks the tree, visiting the children first, converting them into
  * a value, and then attempts to reduce the parent. Eventually, the single final value is returned.
  */
-interface Reducer <out T> {
+interface Reducer<out T> {
 
     /**
      * Reduces the given tree node, given its already reduced children.
@@ -14,6 +14,6 @@ interface Reducer <out T> {
      * @param treeNode the tree node to reduce.
      * @param children the list of children, of type T.
      */
-    fun reduceNode(treeNode: TreeNode, vararg children: Any) : T?
+    fun reduceNode(treeNode: TreeNode, vararg children: Any): T
 
 }

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

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

core/src/main/kotlin/org/nwapw/abacus/tree/TreeValueBinaryNode.kt

@@ -0,0 +1,21 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A tree node that represents a binary tree value operator.
+ *
+ *
+ * The tree value operators operate on trees, and so this
+ * node does not reduce its children. It is up to the implementation to handle
+ * reduction.
+ * @param operation the operation this node performs.
+ * @param left the left child of this node.
+ * @param right the right child of this node.
+ */
+class TreeValueBinaryNode(operation: String, left: TreeNode, right: TreeNode)
+    : BinaryNode(operation, left, right) {
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
+        return reducer.reduceNode(this)
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/tree/TreeValueFunctionNode.kt

@@ -0,0 +1,16 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A tree node that represents a tree value function call.
+ *
+ * This is in many ways similar to a simple FunctionNode, and the distinction
+ * is mostly to help the reducer. Besides that, this class also does not
+ * even attempt to reduce its children.
+ */
+class TreeValueFunctionNode(name: String, children: List<TreeNode>) : CallNode(name, children) {
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
+        return reducer.reduceNode(this)
+    }
+
+}

core/src/main/kotlin/org/nwapw/abacus/tree/TreeValueUnaryNode.kt

@@ -0,0 +1,19 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A tree node that represents a unary tree value operator.
+ *
+ * The tree value operators operate on trees, and so this
+ * node does not reduce its children. It is up to the implementation to handle
+ * reduction.
+ * @param operation the operation this node performs.
+ * @param child the node the operation should be applied to.
+ */
+class TreeValueUnaryNode(operation: String, child: TreeNode)
+    : UnaryNode(operation, child) {
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
+        return reducer.reduceNode(this)
+    }
+
+}

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

@@ -9,15 +9,10 @@ package org.nwapw.abacus.tree
  * @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)
-    }
+abstract class UnaryNode(val operation: String, val applyTo: TreeNode) : TreeNode() {
 
     override fun toString(): String {
-        return "(" + (applyTo?.toString() ?: "null") + ")" + operation
+        return "(" + applyTo.toString() + ")" + operation
     }
 
 }

core/src/main/kotlin/org/nwapw/abacus/tree/VariableNode.kt

@@ -0,0 +1,21 @@
+package org.nwapw.abacus.tree
+
+/**
+ * A tree node that holds a placeholder variable.
+ *
+ * This node holds a variable string, and acts similarly to a number,
+ * with the key difference of not actually holding a value at runtime.
+ *
+ * @param variable the actual variable name that this node represents.
+ */
+class VariableNode(val variable: String) : TreeNode() {
+
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
+        return reducer.reduceNode(this)
+    }
+
+    override fun toString(): String {
+        return variable
+    }
+
+}

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

@@ -5,87 +5,89 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.config.Configuration;
+import org.nwapw.abacus.exception.DomainException;
 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[]{}));
+    private static Abacus abacus = new Abacus(new Configuration( "precise", new String[]{}));
 
     @BeforeClass
-    public static void prepareTests(){
+    public static void prepareTests() {
         abacus.getPluginManager().addInstantiated(new StandardPlugin(abacus.getPluginManager()));
-        abacus.getPluginManager().load();
+        abacus.reload();
     }
 
-    private void testOutput(String input, String parseOutput, String output){
+    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);
+        NumberInterface result = abacus.evaluateTree(parsedTree).getValue();
         Assert.assertNotNull(result);
         Assert.assertTrue(result.toString().startsWith(output));
     }
 
-    private void testEvalError(String input, String parseOutput){
+    private void testDomainException(String input, String parseOutput) {
         TreeNode parsedTree = abacus.parseString(input);
-        Assert.assertNotNull(parsedTree);
         Assert.assertEquals(parsedTree.toString(), parseOutput);
-        Assert.assertNull(abacus.evaluateTree(parsedTree));
+        try {
+            abacus.evaluateTree(parsedTree);
+            Assert.fail("Function did not throw DomainException.");
+        } catch (DomainException e){ }
     }
 
     @Test
-    public void testAddition(){
+    public void testAddition() {
         testOutput("9.5+10", "(9.5+10)", "19.5");
     }
 
     @Test
-    public void testSubtraction(){
+    public void testSubtraction() {
         testOutput("9.5-10", "(9.5-10)", "-0.5");
     }
 
     @Test
-    public void testMultiplication(){
+    public void testMultiplication() {
         testOutput("9.5*10", "(9.5*10)", "95");
     }
 
     @Test
-    public void testDivision(){
+    public void testDivision() {
         testOutput("9.5/2", "(9.5/2)", "4.75");
     }
 
     @Test
-    public void testNegation(){
+    public void testNegation() {
         testOutput("-9.5", "(9.5)`", "-9.5");
     }
 
     @Test
-    public void testFactorial(){
+    public void testFactorial() {
         testOutput("7!", "(7)!", "5040");
     }
 
     @Test
-    public void testAbs(){
+    public void testAbs() {
         testOutput("abs(-1)", "abs((1)`)", "1");
         testOutput("abs(1)", "abs(1)", "1");
     }
 
     @Test
-    public void testLn(){
-        testEvalError("ln(-1)", "ln((1)`)");
+    public void testLn() {
+        testDomainException("ln(-1)", "ln((1)`)");
         testOutput("ln2", "ln(2)", "0.6931471805599453094172321214581765680755");
     }
 
     @Test
-    public void testSqrt(){
+    public void testSqrt() {
         testOutput("sqrt0", "sqrt(0)", "0");
         testOutput("sqrt4", "sqrt(4)", "2");
         testOutput("sqrt2", "sqrt(2)", "1.4142135623730950488016887242096980785696");
     }
 
     @Test
-    public void testExp(){
+    public void testExp() {
         testOutput("exp0", "exp(0)", "1");
         testOutput("exp1", "exp(1)", "2.718281828459045235360287471352662497757247");
         testOutput("exp300", "exp(300)", "1.9424263952412559365842088360176992193662086");
@@ -93,15 +95,15 @@ public class CalculationTests {
     }
 
     @Test
-    public void testPow(){
+    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");
         testOutput("7^(-sqrt2*17)", "(7^((sqrt(2)*17))`)", "4.81354609155297814551845300063563");
-        testEvalError("0^0", "(0^0)");
-        testEvalError("(-13)^.9999", "((13)`^0.9999)");
+        testDomainException("0^0", "(0^0)");
+        testDomainException("(-13)^.9999", "((13)`^.9999)");
     }
 
 }

core/src/test/java/org/nwapw/abacus/tests/RangeTests.java

@@ -0,0 +1,97 @@
+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.NaiveNumber;
+import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.number.NumberRange;
+import org.nwapw.abacus.number.PreciseNumber;
+import org.nwapw.abacus.plugin.StandardPlugin;
+
+import java.util.function.Function;
+
+public class RangeTests {
+
+    private static Abacus abacus = new Abacus(new Configuration( "precise", new String[]{}));
+    private static Function<NumberInterface, NumberInterface> naivePromotion = i -> new NaiveNumber((i.toString()));
+    private static Function<NumberInterface, NumberInterface> precisePromotion = i -> new PreciseNumber((i.toString()));
+
+    @BeforeClass
+    public static void prepareTests() {
+        abacus.getPluginManager().addInstantiated(new StandardPlugin(abacus.getPluginManager()));
+        abacus.reload();
+    }
+
+    public static NumberRange naiveRange(String bottom, String top) {
+        return new NaiveNumber(bottom).rangeTo(new NaiveNumber(top)).with(abacus);
+    }
+
+    @Test
+    public void testNaiveRange(){
+        NumberRange range = naiveRange("0", "10");
+        Assert.assertTrue(range.getStart().toString().startsWith("0"));
+        Assert.assertTrue(range.getEndInclusive().toString().startsWith("10"));
+    }
+
+    @Test
+    public void testNaiveRangeBelow() {
+        NumberRange range = naiveRange("0", "10");
+        Assert.assertFalse(range.contains(new NaiveNumber("-10")));
+    }
+
+    @Test
+    public void testNaiveRangeAbove() {
+        NumberRange range = naiveRange("0", "10");
+        Assert.assertFalse(range.contains(new NaiveNumber("20")));
+    }
+
+    @Test
+    public void testNaiveRangeJustWithinBottom() {
+        NumberRange range = naiveRange("0", "10");
+        Assert.assertTrue(range.contains(new NaiveNumber("0")));
+    }
+
+    @Test
+    public void testNaiveRangeJustWithinTop() {
+        NumberRange range = naiveRange("0", "10");
+        Assert.assertTrue(range.contains(new NaiveNumber("10")));
+    }
+
+    @Test
+    public void testNaiveRangeWithin() {
+        NumberRange range = naiveRange("0", "10");
+        Assert.assertTrue(range.contains(new NaiveNumber("5")));
+    }
+
+    public static void addTestPromotionPaths() {
+        StandardPlugin.IMPLEMENTATION_NAIVE.getPromotionPaths().put("precise", precisePromotion);
+        StandardPlugin.IMPLEMENTATION_PRECISE.getPromotionPaths().put("naive", naivePromotion);
+        abacus.reload();
+    }
+
+    public static void removeTestPromotionPaths() {
+        StandardPlugin.IMPLEMENTATION_NAIVE.getPromotionPaths().remove("precise");
+        StandardPlugin.IMPLEMENTATION_NAIVE.getPromotionPaths().remove("naive");
+        abacus.reload();
+    }
+
+    @Test
+    public void testPromotionWithin() {
+        addTestPromotionPaths();
+        NumberRange range = naiveRange("0", "10");
+        Assert.assertTrue(range.contains(new PreciseNumber("5")));
+        removeTestPromotionPaths();
+    }
+
+    @Test
+    public void testPromotionOutside(){
+        addTestPromotionPaths();
+        NumberRange range = naiveRange("0","10");
+        Assert.assertFalse(range.contains(new PreciseNumber("20")));
+        removeTestPromotionPaths();
+    }
+
+}

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

@@ -5,10 +5,8 @@ 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;
-import org.nwapw.abacus.function.OperatorType;
+import org.nwapw.abacus.context.MutableEvaluationContext;
+import org.nwapw.abacus.function.*;
 import org.nwapw.abacus.lexing.pattern.Match;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.parsing.LexerTokenizer;
@@ -19,26 +17,48 @@ import java.util.List;
 
 public class TokenizerTests {
 
-    private static Abacus abacus = new Abacus(new Configuration(0, "precise", new String[]{}));
+    private static Abacus abacus = new Abacus(new Configuration("precise", new String[]{}));
     private static LexerTokenizer lexerTokenizer = new LexerTokenizer();
-    private static Function subtractFunction = new Function() {
+    private static NumberFunction subtractFunction = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].subtract(params[1]);
         }
     };
     private static Plugin testPlugin = new Plugin(abacus.getPluginManager()) {
         @Override
         public void onEnable() {
-            registerOperator("+", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
-                    0, subtractFunction));
-            registerOperator("-", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
-                    0, subtractFunction));
+            registerOperator("+", new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
+                    0) {
+
+                @Override
+                public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
+                    return true;
+                }
+
+                                @Override
+                public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+                    return subtractFunction.apply(context, params);
+                }
+            });
+            registerOperator("-", new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
+                    0) {
+
+                @Override
+                public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
+                    return true;
+                }
+
+                                @Override
+                public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+                    return subtractFunction.apply(context, params);
+                }
+            });
             registerFunction("subtract", subtractFunction);
         }
 
@@ -60,7 +80,7 @@ public class TokenizerTests {
     public static void prepareTests() {
         abacus.getPluginManager().addListener(lexerTokenizer);
         abacus.getPluginManager().addInstantiated(testPlugin);
-        abacus.getPluginManager().load();
+        abacus.reload();
     }
 
     @Test

docs/404.html

@@ -0,0 +1,7 @@
+---
+layout: base 
+---
+<h1>404</h1>
+
+<p><strong>Page not found :(</strong></p>
+<p>The requested page could not be found.</p>

docs/Gemfile

@@ -0,0 +1,27 @@
+source "https://rubygems.org"
+
+# Hello! This is where you manage which Jekyll version is used to run.
+# When you want to use a different version, change it below, save the
+# file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
+#
+#     bundle exec jekyll serve
+#
+# This will help ensure the proper Jekyll version is running.
+# Happy Jekylling!
+gem "jekyll", "3.5.2"
+
+# This is the default theme for new Jekyll sites. You may change this to anything you like.
+gem "minima", "~> 2.0"
+
+# If you want to use GitHub Pages, remove the "gem "jekyll"" above and
+# uncomment the line below. To upgrade, run `bundle update github-pages`.
+# gem "github-pages", group: :jekyll_plugins
+
+# If you have any plugins, put them here!
+group :jekyll_plugins do
+   gem "jekyll-feed", "~> 0.6"
+end
+
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby]
+

docs/Gemfile.lock

@@ -0,0 +1,58 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.5.1)
+      public_suffix (~> 2.0, >= 2.0.2)
+    colorator (1.1.0)
+    ffi (1.9.18)
+    forwardable-extended (2.6.0)
+    jekyll (3.5.2)
+      addressable (~> 2.4)
+      colorator (~> 1.0)
+      jekyll-sass-converter (~> 1.0)
+      jekyll-watch (~> 1.1)
+      kramdown (~> 1.3)
+      liquid (~> 4.0)
+      mercenary (~> 0.3.3)
+      pathutil (~> 0.9)
+      rouge (~> 1.7)
+      safe_yaml (~> 1.0)
+    jekyll-feed (0.9.2)
+      jekyll (~> 3.3)
+    jekyll-sass-converter (1.5.0)
+      sass (~> 3.4)
+    jekyll-watch (1.5.0)
+      listen (~> 3.0, < 3.1)
+    kramdown (1.14.0)
+    liquid (4.0.0)
+    listen (3.0.8)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    mercenary (0.3.6)
+    minima (2.1.1)
+      jekyll (~> 3.3)
+    pathutil (0.14.0)
+      forwardable-extended (~> 2.6)
+    public_suffix (2.0.5)
+    rb-fsevent (0.10.2)
+    rb-inotify (0.9.10)
+      ffi (>= 0.5.0, < 2)
+    rouge (1.11.1)
+    safe_yaml (1.0.4)
+    sass (3.5.1)
+      sass-listen (~> 4.0.0)
+    sass-listen (4.0.0)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jekyll (= 3.5.2)
+  jekyll-feed (~> 0.6)
+  minima (~> 2.0)
+  tzinfo-data
+
+BUNDLED WITH
+   1.15.3

docs/_config.yml

@@ -0,0 +1,43 @@
+# Welcome to Jekyll!
+#
+# This config file is meant for settings that affect your whole blog, values
+# which you are expected to set up once and rarely edit after that. If you find
+# yourself editing this file very often, consider using Jekyll's data files
+# feature for the data you need to update frequently.
+#
+# For technical reasons, this file is *NOT* reloaded automatically when you use
+# 'bundle exec jekyll serve'. If you change this file, please restart the server process.
+
+# Site settings
+# These are used to personalize your new site. If you look in the HTML files,
+# you will see them accessed via {{ site.title }}, {{ site.email }}, and so on.
+# You can create any custom variable you would like, and they will be accessible
+# in the templates via {{ site.myvariable }}.
+title: Abacus
+email: danila.fedorin@gmail.com
+description: > # this means to ignore newlines until "baseurl:"
+  This is the home page of Abacus,
+  a calculator developed during
+  the summer of 2017 as a tool
+  for the more tech-savvy users.
+baseurl: "/abacus" # the subpath of your site, e.g. /blog
+url: "htts://danilafe.github.io" # the base hostname & protocol for your site, e.g. http://example.com
+github_username: DanilaFe 
+include: ['_pages']
+
+# Build settings
+markdown: kramdown
+plugins:
+  - jekyll-feed
+
+# Exclude from processing.
+# The following items will not be processed, by default. Create a custom list
+# to override the default setting.
+# exclude:
+#   - Gemfile
+#   - Gemfile.lock
+#   - node_modules
+#   - vendor/bundle/
+#   - vendor/cache/
+#   - vendor/gems/
+#   - vendor/ruby/

docs/_includes/head.html

@@ -0,0 +1,17 @@
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+
+  <title>{% if page.title %}{{ page.title | escape }}{% else %}{{ site.title | escape }}{% endif %}</title>
+  <meta name="description" content="{{ page.excerpt | default: site.description | strip_html | normalize_whitespace | truncate: 160 | escape }}">
+
+  <link rel="stylesheet" href="{{ "assets/css/main.css" | relative_url }}">
+  <link rel="canonical" href="{{ page.url | replace:'index.html','' | absolute_url }}">
+  <link rel="alternate" type="application/rss+xml" title="{{ site.title | escape }}" href="{{ "/feed.xml" | relative_url }}">
+  
+  {% if jekyll.environment == 'production' and site.google_analytics %}
+  {% include google-analytics.html %}
+  {% endif %}
+</head>
+

docs/_includes/header.html

@@ -0,0 +1,10 @@
+<nav>
+  <div class="center">
+    <a href="{{ "/" | relative_url }}" class="primary-link">{{ site.title }}</a>
+    {% for page in site.pages %}
+    {% if page.in_header %}
+    <a href="{{ page.url | relative_url }}">{{ page.title }}</a>
+    {% endif %}
+    {% endfor %}
+  </div>
+</nav>

docs/_layouts/base.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+
+  {% include head.html %}
+
+  <body>
+    {% include header.html %}
+
+    <div class="content center">
+      {{ content }}
+    </div>
+
+    {% include footer.html %}
+  </body>
+
+
+</html>

docs/_layouts/home.html

@@ -0,0 +1,159 @@
+<!DOCTYPE html>
+<html>
+  {% include head.html %}
+  <style>
+  body {
+    margin: 0px;
+    margin-top: 50px;
+    color: white;
+    text-align: center;
+  }
+  h1, h2, h3, h4, h5, h6 {
+    font-family: "Source Code Pro"
+  }
+
+  img#logo {
+    margin: auto;
+    width: 100%;
+    max-width: 100px;
+  }
+
+  img#image_preview {
+    margin: auto;
+    width: 100%;
+    max-width: 432px;
+  }
+
+  div#buttons {
+    margin-top: 40px;
+    margin-bottom: 40px;
+  }
+
+  a {
+    background-color: white;
+    color: #06e8a4;
+  }
+
+  a:hover {
+    background-color: #06e8a4;
+    color: white;
+  }
+
+  div.fullwidth {
+    width: 100%;
+    height: auto;
+    overflow: hidden;
+  }
+
+  div.fullwidth img {
+    max-width: 100%;
+    max-height: 450px;
+    margin: auto;
+    margin-top: 20px;
+    margin-bottom: 20px;
+    display: block;
+    border-radius: 5px;
+  }
+
+  div.white {
+    background-color: white;
+    color: black;
+  }
+
+  div.green {
+    background-color: #06e8a4;
+    color: white;
+  }
+
+  div.fullwidth div.double {
+    height: 100%;
+    text-align: left;
+    width: 50%;
+    box-sizing: border-box;
+    padding: 40px;
+    float: left;
+    background-color: inherit;
+  }
+
+  @media (max-width: 750px) {
+    div.fullwidth div.double {
+      width: 100%;
+      padding: 15px;
+    }
+    div.fullwidth img {
+      margin-top: 0px;
+      margin-bottom: 0px;
+    }
+  }
+
+  div.fullwidth div.double h1, h2, h3, h4, h5, h6 {
+    text-align: center;
+  }
+
+  </style>
+  <body>
+  <img src="https://raw.githubusercontent.com/DanilaFe/abacus/master/image/logo.png" id="logo">
+  <h1>Abacus</h1>
+  <h2>The programmer's calculator</h2>
+  <div id="buttons">
+    <a class="button inverted" href="{{ "/download" | relative_url }}">Download</a>
+    <a class="button inverted" href="{{ "/about" | relative_url }}">About</a>
+    <a class="button inverted" href="https://github.com/DanilaFe/abacus">Contribute</a>
+    <a class="button inverted" href="https://github.com/DanilaFe/abacus/wiki">Wiki</a>
+  </div>
+  <img src="http://i.imgur.com/Min70QY.png" title="source: imgur.com" id="image_preview"/>
+  <h2>Features</h2>
+  <div class="fullwidth white">
+    <div class="double">
+      <img src="https://i.imgur.com/gmGJBBK.png">
+    </div>
+    <div class="double">
+      <h2>Precision</h2>
+      Abacus uses a mathematical tool called Taylor Series to determine values
+      as accurate as the user desires. Of course, this comes with some
+      performance issues with larger numbers. However, Abacus has been
+      tested to generate the value of e correctly to a thousand digits.
+    </div>
+  </div>
+  <div class="fullwidth green">
+    <div class="double">
+      <h2>Configurable and Customizable</h2>
+      The very first idea for Abacus was inspired by how difficult it was
+      to program a TI-84 calculator. Only two languages were available, TI-BASIC
+      and Assembly, the latter having virtually no documentation. Determined
+      to be better than a TI-84, Abacus implemented a plugin system that allows
+      users to easily create and add plugins written in the same programming
+      language as Abacus itself - Java. These plugins can access the full
+      power of the language, and implement their own ways of handling numbers,
+      as well as their own functions and even operators.<br><br>
+      Besides the ability to add plugins, Abacus also adds some general
+      options that can be used to make the user's experience more pleasant.
+      For instance, it allows for a computation limit to be set in order
+      to prevent excessively long evaluation: 8!!! is, for example, an expression
+      that even Wolfram Alpha doesn't compute accurately, and will never finish
+      on Abacus (it's simply too large). The computation limit will allow Abacus
+      to kill a computation if it takes too long. Support for user-definable
+      precision is also planned.
+    </div>
+    <div class="double">
+      <img src="https://i.imgur.com/JzenWPV.png">
+    </div>
+  </div>
+  <div class="fullwidth white">
+    <div class="double">
+      <img src="https://i.imgur.com/jY17I3A.png">
+    </div>
+    <div class="double">
+      <h2>Built-in Documentation</h2>
+      Abacus plugins are given a mechanism to register documentation for
+      the functions that they provide. The Abacus GUI displays these
+      functions in a searchable list, allowing the user to read the parameters
+      that have to be supplied to each function, as well as learn about
+      its return value.<br><br>
+      The search finds functions not only by their names, but also by relevant
+      terms mentioned in the function's description, thus allowing related
+      functions to be displayed together.
+    </div>
+  </div>
+  </body>
+</html>

docs/_layouts/page.html

@@ -0,0 +1,5 @@
+---
+layout: base
+---
+<h1>{{ page.title }}</h1>
+{{ content }}

docs/_pages/about.md

@@ -0,0 +1,27 @@
+---
+in_header: true
+layout: page
+title: About
+permalink: /about/
+---
+
+## So... what IS Abacus?
+It's a calculator. Obviously. But what makes it better than
+what already exists? There's a few things. Abacus is:
+* Programmable, and not in TI Basic.
+* Precise. With the "precise" option, Abacus can keep up to 50 significant figures.
+* Capable. Ever wonder what 2<sup>700</sup> is? How about 8!!? Abacus can tell you!
+* Offline. While Wolfram Alpha can do powerful math, it needs internet connection!
+* Built for the desktop. Why use buttons on the screen when there's buttons on the keyboard?
+* Open source. Don't like something? Help is always welcome!
+
+## Why was Abacus made?
+The initial project was proposed for the [Northwest Advanced Programming Workshop](http://nwapw.org/about/).
+You can read the project proposal on the main GitHub page, although the idea has
+changed quite a bit, mostly in shifting from "fast" to "precise".
+
+## What is Abacus made with?
+Java and Kotlin. Java provides a good layer of abstraction and a great standard
+library, while Kotlin allows for the reduction of boilerplate code and null
+safety. Using JVM-based languages also allows Abacus to expose its entire
+API to plugins, and load them at runtime.

docs/_pages/download.md

@@ -0,0 +1,34 @@
+---
+in_header: true
+layout: page
+title: Download
+permalink: /download/
+---
+
+Currently, we do not provide standalone executables due to our unfamiliarity with
+including 3rd-party software. Abacus uses a number of open source libraries,
+and we do not want to breach the license terms for any of them. As soon as
+as we figure out the correct way to distribute Abacus, we will make a
+standalone distribution available. In the meantime, please use the below
+steps to run Abacus from source.
+
+## Getting the Code
+Abacus is an open source project, and is distributed under the MIT license.
+If you would like to download the source code, simply clone it from
+[GitHub](https://github.com/DanilaFe/abacus).
+Alternatively, if you don't want the bleeding edge version, check out the
+[releases](https://github.com/DanilaFe/abacus/releases).
+
+## Running from Source
+Once you have unpacked the source code, you can simply run it from
+the command line via the shell command:
+```
+./gradlew run
+```
+If you're on Windows, the command is similar:
+```
+gradlew run
+```
+This should download a distribution of Gradle, a build system that is
+used to compile Abacus. After some time, the Abacus window should appear.
+From there, you can use it normally.

docs/assets/css/main.scss

@@ -0,0 +1,119 @@
+---
+---
+@import url('https://fonts.googleapis.com/css?family=Source+Code+Pro|Open+Sans|Raleway');
+
+$background-color: #19d69e;
+$code-color: #efefef;
+$accent-color: #00AFE8;
+$clear-color: white;
+$title-font: "Open Sans";
+$text-font: "Raleway";
+$code-font: "Source Code Pro";
+$max-width: 850px;
+
+a {
+  text-decoration: none;
+  color: $background-color;
+
+  &.button {
+    display: inline-block;
+    background-color: $background-color;
+    color: $clear-color;
+    padding: 10px;
+    text-decoration: none;
+    border-radius: 2px;
+
+    margin: 10px;
+    transition: background-color .25s;
+
+    &:hover {
+      background-color: $clear-color;
+      color: $background-color;
+    }
+
+    &.inverted {
+      background-color: $clear-color;
+      color: $background-color;
+
+      &:hover {
+        background-color: $background-color;
+        color: $clear-color;
+      }
+    }
+  }
+}
+
+h1, h2, h3, h4, h5, h6 {
+  font: {
+    family: $title-font;
+  }
+}
+
+h1 {
+  font-size: 50px;
+}
+
+nav {
+  box-sizing: border-box;
+  background-color: $clear-color;
+  width: 100%;
+  padding: 20px;
+
+  a {
+    text-decoration: none;
+    color: $background-color;
+    font-size: 20px;
+    margin-right: 10px;
+
+    &.primary-link {
+      font-size: 30px;
+      margin-right: 20px;
+    }
+
+    &:hover {
+      color: $accent-color;
+    }
+
+    transition: color .25s;
+  }
+}
+
+body {
+  background-color: $background-color;
+  font: {
+    family: $text-font;
+  }
+  margin: 0px;
+}
+
+.center {
+  box-sizing: border-box;
+  width: 100%;
+  max-width: $max-width;
+
+  @media (min-width: $max-width) {
+    margin: {
+      left: auto;
+      right: auto;
+    }
+  }
+}
+
+.content {
+  margin-top: 20px;
+  padding: 30px;
+  background-color: $clear-color;
+}
+
+code {
+  background-color: $code-color;
+  display: inline-block;
+  padding: 5px;
+  font-family: $code-font;
+
+  pre & {
+    padding: 10px;
+    display: block;
+    width: 100%;
+  }
+}

docs/index.md

@@ -0,0 +1,6 @@
+---
+# You don't need to edit this file, it's empty on purpose.
+# Edit theme's home layout instead if you wanna make some changes
+# See: https://jekyllrb.com/docs/themes/#overriding-theme-defaults
+layout: home
+---

fx/build.gradle

@@ -1,10 +1,15 @@
-plugins {
-  id 'org.jetbrains.kotlin.jvm' version '1.1.3'
-}
 apply plugin: 'application'
 
 dependencies {
-  compile project(':core')
+    compile 'com.moandjiezana.toml:toml4j:0.7.1'
+    compile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.18'
+    compile project(':core')
+}
+
+kotlin {
+    experimental {
+        coroutines "enable"
+    }
 }
 
 mainClassName = 'org.nwapw.abacus.fx.AbacusApplication'

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

@@ -17,6 +17,10 @@ public class AbacusApplication extends Application {
      */
     private AbacusController controller;
 
+    public static void main(String[] args) {
+        launch(args);
+    }
+
     @Override
     public void start(Stage primaryStage) throws Exception {
         FXMLLoader loader = new FXMLLoader(getClass().getResource("/abacus.fxml"));
@@ -34,8 +38,4 @@ public class AbacusApplication extends Application {
         controller.performStop();
     }
 
-    public static void main(String[] args){
-        launch(args);
-    }
-
 }

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

@@ -1,13 +1,10 @@
 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;
@@ -15,14 +12,15 @@ import javafx.util.Callback;
 import javafx.util.StringConverter;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.config.Configuration;
+import org.nwapw.abacus.exception.AbacusException;
 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.number.*;
 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.EvaluationResult;
 import org.nwapw.abacus.tree.TreeNode;
 
 import java.io.File;
@@ -136,51 +134,23 @@ public class AbacusController implements PluginListener {
      * 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(){
+        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;
-                }
+                EvaluationResult result = abacus.evaluateTree(constructedTree);
+                NumberInterface evaluatedNumber = result.getValue();
                 String resultingString = evaluatedNumber.toString();
                 historyData.add(new HistoryModel(inputField.getText(), constructedTree.toString(), resultingString));
+                abacus.applyToContext(result.getResultingContext());
                 return resultingString;
-            } catch (ComputationInterruptedException exception) {
-                return ERR_STOP;
-            } catch (RuntimeException exception){
+            } catch (AbacusException exception) {
+                return exception.getMessage();
+            } catch (RuntimeException exception) {
                 exception.printStackTrace();
                 return ERR_EXCEPTION;
             }
@@ -197,6 +167,18 @@ public class AbacusController implements PluginListener {
             });
         }
     };
+    /**
+     * 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 thread that is waiting to pause the calculation.
      */
@@ -205,6 +187,18 @@ public class AbacusController implements PluginListener {
      * The thread in which the computation runs.
      */
     private Thread calculationThread;
+    /**
+     * The runnable that takes care of killing computations that take too long.
+     */
+    private final Runnable TIMER_RUNNABLE = () -> {
+        try {
+            ExtendedConfiguration abacusConfig = (ExtendedConfiguration) abacus.getConfiguration();
+            if (abacusConfig.getComputationDelay() == 0) return;
+            Thread.sleep((long) (abacusConfig.getComputationDelay() * 1000));
+            performStop();
+        } catch (InterruptedException e) {
+        }
+    };
 
     /**
      * Alerts the user if the changes they made
@@ -258,14 +252,14 @@ public class AbacusController implements PluginListener {
             if (oldValue.equals(settingsTab)) alertIfApplyNeeded(true);
         });
 
-        abacus = new Abacus(new Configuration(CONFIG_FILE));
+        abacus = new Abacus(new ExtendedConfiguration(CONFIG_FILE));
         PluginManager abacusPluginManager = abacus.getPluginManager();
         abacusPluginManager.addListener(this);
         performScan();
 
-        computationLimitField.setText(Double.toString(abacus.getConfiguration().getComputationDelay()));
+        computationLimitField.setText(Double.toString(((ExtendedConfiguration) abacus.getConfiguration()).getComputationDelay()));
         computationLimitField.textProperty().addListener((observable, oldValue, newValue) -> {
-            if(!newValue.matches("(\\d+(\\.\\d*)?)?")) {
+            if (!newValue.matches("(\\d+(\\.\\d*)?)?")) {
                 computationLimitField.setText(oldValue);
             } else {
                 changesMade = true;
@@ -292,12 +286,12 @@ public class AbacusController implements PluginListener {
     }
 
     @FXML
-    public void performStop(){
-        if(calculationThread != null) {
+    public void performStop() {
+        if (calculationThread != null) {
             calculationThread.interrupt();
             calculationThread = null;
         }
-        if(computationLimitThread != null){
+        if (computationLimitThread != null) {
             computationLimitThread.interrupt();
             computationLimitThread = null;
         }
@@ -312,7 +306,7 @@ public class AbacusController implements PluginListener {
     }
 
     @FXML
-    public void performScan(){
+    public void performScan() {
         PluginManager abacusPluginManager = abacus.getPluginManager();
         abacusPluginManager.removeAll();
         abacusPluginManager.addInstantiated(new StandardPlugin(abacus.getPluginManager()));
@@ -321,13 +315,13 @@ public class AbacusController implements PluginListener {
         } catch (IOException | ClassNotFoundException e) {
             e.printStackTrace();
         }
-        abacusPluginManager.reload();
+        abacus.reload();
     }
 
     @FXML
     public void performReload() {
         alertIfApplyNeeded(true);
-        abacus.getPluginManager().reload();
+        abacus.reload();
     }
 
     @FXML
@@ -339,9 +333,9 @@ public class AbacusController implements PluginListener {
         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);
+        if (computationLimitField.getText().matches("\\d*(\\.\\d+)?") && computationLimitField.getText().length() != 0)
+            ((ExtendedConfiguration) configuration).setComputationDelay(Double.parseDouble(computationLimitField.getText()));
+        ((ExtendedConfiguration) configuration).saveTo(CONFIG_FILE);
         changesMade = false;
         reloadAlertShown = false;
     }
@@ -361,7 +355,14 @@ public class AbacusController implements PluginListener {
             enabledPlugins.add(plugin);
         }
         PluginManager pluginManager = abacus.getPluginManager();
-        functionList.addAll(manager.getAllFunctions().stream().map(name -> pluginManager.documentationFor(name, DocumentationType.FUNCTION))
+        functionList.addAll(manager.getAllFunctions().stream().map(name -> {
+            Documentation documentationInstance = pluginManager.documentationFor(name, DocumentationType.FUNCTION);
+            if(documentationInstance == null)
+                documentationInstance = new Documentation(name, "", "", "", DocumentationType.FUNCTION);
+            return documentationInstance;
+        })
+                .collect(Collectors.toCollection(ArrayList::new)));
+        functionList.addAll(manager.getAllTreeValueFunctions().stream().map(name -> pluginManager.documentationFor(name, DocumentationType.TREE_VALUE_FUNCTION))
                 .collect(Collectors.toCollection(ArrayList::new)));
         functionList.sort(Comparator.comparing(Documentation::getCodeName));
     }

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

@@ -14,7 +14,7 @@ public class DocumentationCell extends ListCell<Documentation> {
     private Label longDescription;
     private TitledPane titledPane;
 
-    public DocumentationCell(){
+    public DocumentationCell() {
         VBox vbox = new VBox();
         vbox.setSpacing(10);
         titledPane = new TitledPane();
@@ -41,7 +41,7 @@ public class DocumentationCell extends ListCell<Documentation> {
     @Override
     protected void updateItem(Documentation item, boolean empty) {
         super.updateItem(item, empty);
-        if(empty){
+        if (empty) {
             codeNameLabel.setText("");
             nameLabel.setText("");
             description.setText("");

fx/src/main/kotlin/org/nwapw/abacus/fx/ExtendedConfiguration.kt

@@ -0,0 +1,72 @@
+package org.nwapw.abacus.fx
+
+import com.moandjiezana.toml.Toml
+import com.moandjiezana.toml.TomlWriter
+import org.nwapw.abacus.config.Configuration
+import java.io.File
+
+/**
+ * Additional settings for user interface.
+ *
+ * ExtendedConfiguration is used to add other settings
+ * that aren't built into Abacus core, but are necessary
+ * for the fx module.
+ *
+ * @property computationDelay the delay before which the computation stops.
+ * @param implementation the number implementation, same as [Configuration.numberImplementation]
+ * @param disabledPlugins the list of plugins that should be disabled, same as [Configuration.disabledPlugins]
+ */
+class ExtendedConfiguration(var computationDelay: Double = 0.0,
+                     implementation: String = "<default>",
+                     disabledPlugins: Array<String> = emptyArray())
+    : Configuration(implementation, disabledPlugins) {
+
+    companion object {
+        /**
+         * The default TOML.
+         */
+        val DEFAULT_TOML_STRING = """
+            computationDelay=0.0
+            implementation="naive"
+            disabledPlugins=[]
+            """
+        /**
+         * A reader with the default TOML data.
+         */
+        val DEFAULT_TOML_READER = Toml().read(DEFAULT_TOML_STRING)
+        /**
+         * A writer used to writing the configuration to disk.
+         */
+        val DEFAULT_TOML_WRITER = TomlWriter()
+    }
+
+    /**
+     * Constructs a new configuration from a file on disk.
+     * @param tomlFile the file from disk to load.
+     */
+    constructor(tomlFile: File) : this() {
+        val toml = Toml(DEFAULT_TOML_READER)
+        if(tomlFile.exists()) toml.read(tomlFile)
+        copyFrom(toml.to(ExtendedConfiguration::class.java))
+    }
+
+    /**
+     * Copies data from another configuration into this one.
+     * @param config the configuration to copy from.
+     */
+    fun copyFrom(config: ExtendedConfiguration) {
+        computationDelay = config.computationDelay
+        numberImplementation = config.numberImplementation
+        disabledPlugins.clear()
+        disabledPlugins.addAll(config.disabledPlugins)
+    }
+
+    /**
+     * Saves this configuration to a file.
+     * @param file the file to save to.
+     */
+    fun saveTo(file: File) {
+        DEFAULT_TOML_WRITER.write(this, file)
+    }
+
+}

fx/src/main/kotlin/org/nwapw/abacus/fx/HistoryModel.kt

@@ -14,7 +14,7 @@ import javafx.beans.property.SimpleStringProperty
  * @param parsed the parsed version of the input.
  * @param output the output string.
  */
-class HistoryModel(input: String, parsed: String, output: String){
+class HistoryModel(input: String, parsed: String, output: String) {
 
     /**
      * The property that holds the input.

fx/src/main/kotlin/org/nwapw/abacus/fx/ToggleablePlugin.kt

@@ -12,7 +12,7 @@ import javafx.beans.property.SimpleBooleanProperty
  * @param className the name of the class that this model concerns.
  * @param enabled whether or not the model should start enabled.
  */
-class ToggleablePlugin (val className: String, enabled: Boolean) {
+class ToggleablePlugin(val className: String, enabled: Boolean) {
 
     /**
      * The property used to interact with JavaFX components.

fx/src/main/kotlin/org/nwapw/abacus/fx/graphing/Graph.kt

@@ -0,0 +1,121 @@
+package org.nwapw.abacus.fx.graphing
+
+import kotlinx.coroutines.experimental.CommonPool
+import kotlinx.coroutines.experimental.async
+import kotlinx.coroutines.experimental.runBlocking
+import org.nwapw.abacus.Abacus
+import org.nwapw.abacus.config.Configuration
+import org.nwapw.abacus.context.EvaluationContext
+import org.nwapw.abacus.context.MutableEvaluationContext
+import org.nwapw.abacus.number.NaiveNumber
+import org.nwapw.abacus.number.NumberInterface
+import org.nwapw.abacus.number.NumberRange
+import org.nwapw.abacus.plugin.StandardPlugin
+import org.nwapw.abacus.tree.TreeNode
+
+/**
+ * A class that holds information about a graph.
+ *
+ * Graph that uses an instance of [Abacus] to generate graphs of an
+ * [expression]. Continuous graphing on large expressions is expensive,
+ * and therefore the method of graphing is discrete. The graph class
+ * uses the [pointExpression] to generate inputs until an input is outside
+ * the function's domain. In both the expressions, the [inputVariable] and
+ * [pointInputVariable] are used, respectively, in order to either pass in
+ * the x-coordinate or the number of the input value being generated.
+ *
+ * @property abacus the abacus instance to use to evaluate expressions.
+ * @property domain the domain used in computation.
+ * @property range the range used for displaying the output.
+ * @property inputVariable the variable which is substituted for the input x-coordinate.
+ * @property pointInputVariable the variable which is substituted for the number of the input point being generated.
+ */
+class Graph(val abacus: Abacus,
+            var domain: NumberRange, var range: NumberRange,
+            var inputVariable: String = "x", var pointInputVariable: String = "n") {
+
+    /**
+     * Property used for storing the parsed version of the [expression]
+     */
+    private var expressionTree: TreeNode? = null
+    /**
+     * Property used for storing the parsed version of the [pointExpression]
+     */
+    private var pointExpressionTree: TreeNode? = null
+
+    /**
+     * The expression being graphed.
+     */
+    var expression: String? = null
+        set(value) {
+            field = value
+            expressionTree = abacus.parseString(value ?: return)
+        }
+    /**
+     * The expression being used to generate points.
+     */
+    var pointExpression: String? = null
+        set(value) {
+            field = value
+            pointExpressionTree = abacus.parseString(value ?: return)
+        }
+
+    /**
+     * Evaluates a parsed expression [tree] with the given input [values] of indeterminate type.
+     * This is is an asynchronous operation using coroutines, and for every input
+     * value a new sub-context is created. The [contextModifier] function is executed
+     * on each new sub-context, and is expected to use the input value to modify the context
+     * state so that the evaluation of the expression produces a correct result.
+     *
+     * @param T the type of input values.
+     * @param tree the tree to evaluate.
+     * @param values the values to plug into the expression.
+     * @param contextModifier the function that plugs values into the context.
+     * @return the list of outputs.
+     */
+    fun <T> evaluateWith(tree: TreeNode, values: List<T>,
+                         contextModifier: MutableEvaluationContext.(T) -> Unit) = runBlocking {
+        values.map {
+            val context = abacus.context.mutableSubInstance()
+            context.contextModifier(it)
+            async(CommonPool) { abacus.evaluateTreeWithContext(tree, context) }
+        }.map { it.await() }
+    }
+
+    /**
+     * Extension function that calls [evaluateWith] with the current list.
+     * @param T the type of the values in the list.
+     * @param tree the tree node to evaluate.
+     * @param contextModifier the function that plugs values into the context.
+     * @return the list of outputs.
+     */
+    fun <T> List<T>.evaluateWith(tree: TreeNode,
+                                 contextModifier: MutableEvaluationContext.(T) -> Unit ) =
+            evaluateWith(tree, this, contextModifier)
+
+    /**
+     * Uses the [pointExpression] and [pointInputVariable] to generate
+     * a set of points as inputs for the actual expression. These points are generated
+     * as long as they are within the [domain].
+     * @return the list of generated input values.
+     */
+    fun generateInputs(): List<NumberInterface> =
+            generateSequence(1) {
+                it + 1
+            }.map {
+                val context = abacus.context.mutableSubInstance()
+                context.setVariable(pointInputVariable,
+                        context.inheritedNumberImplementation!!.instanceForString(it.toString()))
+                abacus.evaluateTreeWithContext(pointExpressionTree!!, context).value
+            }.takeWhile { it in domain }.toList()
+
+    /**
+     * Uses the [expression] and [inputVariable] to generate
+     * a set of outputs from the given set of [inputs].
+     * @return the list of generated points.
+     */
+    fun generateOutputs(inputs: List<NumberInterface>): List<Pair<NumberInterface, NumberInterface>> =
+            inputs.evaluateWith(expressionTree!!) {
+                setVariable(inputVariable, it)
+            }.mapIndexed { index, (value) -> inputs[index] to value }
+}

fx/src/main/kotlin/org/nwapw/abacus/fx/graphing/GraphCanvas.kt

@@ -0,0 +1,39 @@
+package org.nwapw.abacus.fx.graphing
+
+import javafx.beans.value.ChangeListener
+import javafx.scene.canvas.Canvas
+
+/**
+ * A canvas that renders a graph.
+ *
+ * The GraphCanvas uses the provided [Graph] instance in order to draw the outputs on itself.
+ * @param graph the graph used to render.
+ */
+class GraphCanvas(graph: Graph): Canvas() {
+
+    /**
+     * The graph that is currently being used to generate inputs / outputs.
+     * The redraw is triggered if this graph is reset.
+     */
+    var graph: Graph = graph
+        set(value) {
+            field = value
+            redraw()
+        }
+
+    init {
+        val redrawListener = ChangeListener<Number> { _, _, _ -> redraw() }
+        widthProperty().addListener(redrawListener)
+        heightProperty().addListener(redrawListener)
+        redraw()
+    }
+
+    /**
+     * Redraws the graph onto the canvas.
+     */
+    fun redraw() {
+        val graphicsContext = graphicsContext2D
+        val outputs = graph.generateOutputs(graph.generateInputs())
+    }
+
+}

fx/src/main/resources/abacus.fxml

@@ -54,7 +54,7 @@
                     <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="Save" onAction="#performSave"/>
                         <Button text="Reload Plugins" onAction="#performReload"/>
                         <Button text="Apply and Reload" onAction="#performSaveAndReload"/>
                         <Button text="Scan Plugins" onAction="#performScan"/>