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,5 +1,5 @@
 buildscript {
-    ext.kotlin_version = '1.1.3'
+    ext.kotlin_version = '1.1.4-3'
     ext.dokka_version = '0.9.15'
 
     repositories {
@@ -19,7 +19,7 @@ subprojects {
     apply plugin: 'org.jetbrains.dokka'
 
     repositories {
-        mavenCentral()
+        jcenter()
     }
 
     dependencies {

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

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

@@ -1,24 +1,24 @@
-package org.nwapw.abacus.function;
+package org.nwapw.abacus.exception;
 
 /**
  * Exception thrown if the function parameters do not match
  * requirements.
  */
-public class DomainException extends RuntimeException {
+public class DomainException extends AbacusException {
 
     /**
      * Creates a new DomainException.
      * @param reason the reason for which the exception is thrown.
      */
     public DomainException(String reason) {
-        super(reason);
+        super("Domain error", reason);
     }
 
     /**
      * Creates a new DomainException with a default message.
      */
     public DomainException(){
-        this("Domain Error");
+        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/number/NumberInterface.java

@@ -1,9 +1,11 @@
 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
@@ -156,14 +158,6 @@ public abstract class NumberInterface {
         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().
      *
@@ -244,4 +238,16 @@ public abstract class NumberInterface {
      */
     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/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;
@@ -42,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

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

@@ -1,5 +1,6 @@
 package org.nwapw.abacus.parsing;
 
+import org.nwapw.abacus.exception.ParseException;
 import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.function.OperatorAssociativity;
 import org.nwapw.abacus.function.OperatorType;
@@ -99,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();
                 }
@@ -111,7 +112,7 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             if (!(newMatchType == TokenType.OP ||
                     newMatchType == TokenType.TREE_VALUE_OP ||
                     newMatchType == TokenType.FUNCTION ||
-                    newMatchType == TokenType.TREE_VALUE_FUNCTION)) return null;
+                    newMatchType == TokenType.TREE_VALUE_FUNCTION)) throw new ParseException("mismatched parentheses");
             output.add(tokenStack.pop());
         }
         return output;
@@ -124,7 +125,7 @@ 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 || matchType == TokenType.TREE_VALUE_OP) {
@@ -133,7 +134,6 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             if (type == OperatorType.BINARY_INFIX) {
                 TreeNode right = constructRecursive(matches);
                 TreeNode left = constructRecursive(matches);
-                if (left == null || right == null) return null;
                 if (matchType == TokenType.OP) {
                     return new NumberBinaryNode(operator, left, right);
                 } else {
@@ -141,7 +141,6 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                 }
             } else {
                 TreeNode applyTo = constructRecursive(matches);
-                if (applyTo == null) return null;
                 if (matchType == TokenType.OP) {
                     return new NumberUnaryNode(operator, applyTo);
                 } else {
@@ -154,31 +153,32 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             return new VariableNode(match.getContent());
         } else if (matchType == TokenType.FUNCTION || matchType == TokenType.TREE_VALUE_FUNCTION) {
             String functionName = match.getContent();
-            CallNode node;
-            if (matchType == TokenType.FUNCTION) {
-                node = new FunctionNode(functionName);
-            } else {
-                node = new TreeValueFunctionNode(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.getChildren().add(0, 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

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/Plugin.java

@@ -2,7 +2,6 @@ package org.nwapw.abacus.plugin;
 
 import org.nwapw.abacus.function.*;
 import org.nwapw.abacus.number.NumberInterface;
-import org.nwapw.abacus.variables.VariableDatabase;
 
 /**
  * A plugin class that can be externally implemented and loaded via the
@@ -220,12 +219,4 @@ public abstract class Plugin {
      */
     public abstract void onDisable();
 
-    /**
-     * Get the variable database.
-     * @return the variable database.
-     */
-    public final VariableDatabase getVariableDatabase(){
-        return manager.getVariableDatabase();
-    }
-
 }

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

@@ -3,7 +3,6 @@ package org.nwapw.abacus.plugin;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.function.*;
 import org.nwapw.abacus.number.NumberInterface;
-import org.nwapw.abacus.variables.VariableDatabase;
 
 import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
@@ -142,6 +141,7 @@ public class PluginManager {
         registeredNumberImplementations.put(name, implementation);
         interfaceImplementationNames.put(implementation.getImplementation(), name);
         interfaceImplementations.put(implementation.getImplementation(), implementation);
+        cachedPi.put(implementation.getImplementation(), implementation.instanceForPi());
     }
 
     /**
@@ -219,10 +219,6 @@ public class PluginManager {
                 break;
             }
         }
-        if (toReturn == null) {
-            toReturn = new Documentation(name, "", "", "", type);
-            registerDocumentation(toReturn);
-        }
         return toReturn;
     }
 
@@ -253,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);
     }
 
     /**
@@ -423,11 +412,4 @@ public class PluginManager {
         return loadedPluginClasses;
     }
     
-    /**
-     * Gets the variable database.
-     * @return the database.
-     */
-    public VariableDatabase getVariableDatabase(){
-        return abacus.getVariableDatabase();
-    }
 }

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

@@ -1,12 +1,10 @@
 package org.nwapw.abacus.plugin;
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import org.nwapw.abacus.context.MutableEvaluationContext;
 import org.nwapw.abacus.function.*;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.number.PreciseNumber;
-import org.nwapw.abacus.tree.Reducer;
 import org.nwapw.abacus.tree.TreeNode;
 import org.nwapw.abacus.tree.VariableNode;
 
@@ -24,15 +22,15 @@ public class StandardPlugin extends Plugin {
      */
     public final TreeValueOperator opSet = new TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, TreeNode[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, TreeNode[] params) {
             return params.length == 2 && params[0] instanceof VariableNode;
         }
 
         @Override
-        public NumberInterface applyWithReducerInternal(NumberImplementation implementation, Reducer<? extends NumberInterface> reducer, TreeNode[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, TreeNode[] params) {
             String assignTo = ((VariableNode) params[0]).getVariable();
-            NumberInterface value = params[1].reduce(reducer);
-            getVariableDatabase().getVariables().put(assignTo, value);
+            NumberInterface value = params[1].reduce(context.getInheritedReducer());
+            context.setVariable(assignTo, value);
             return value;
         }
     };
@@ -41,16 +39,15 @@ public class StandardPlugin extends Plugin {
      */
     public final TreeValueOperator opDefine = new TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, TreeNode[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, TreeNode[] params) {
             return params.length == 2 && params[0] instanceof VariableNode;
         }
 
-        @Nullable
         @Override
-        public NumberInterface applyWithReducerInternal(NumberImplementation implementation, Reducer<? extends NumberInterface> reducer, TreeNode[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, TreeNode[] params) {
             String assignTo = ((VariableNode) params[0]).getVariable();
-            getVariableDatabase().getDefinitions().put(assignTo, params[1]);
-            return params[1].reduce(reducer);
+            context.setDefinition(assignTo, params[1]);
+            return params[1].reduce(context.getInheritedReducer());
         }
     };
     /**
@@ -58,12 +55,12 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberOperator OP_ADD = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].add(params[1]);
         }
     };
@@ -72,12 +69,12 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberOperator OP_SUBTRACT = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].subtract(params[1]);
 
         }
@@ -87,12 +84,12 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberOperator OP_NEGATE = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.UNARY_PREFIX, 0) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].negate();
         }
     };
@@ -101,12 +98,12 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberOperator OP_MULTIPLY = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].multiply(params[1]);
         }
     };
@@ -135,7 +132,8 @@ public class StandardPlugin extends Plugin {
 
         @Override
         public NumberInterface instanceForPi() {
-            NumberInterface C = FUNCTION_SQRT.apply(this, new PreciseNumber("10005")).multiply(new PreciseNumber("426880"));
+            MutableEvaluationContext dummyContext = new MutableEvaluationContext(null, this, null);
+            NumberInterface C = FUNCTION_SQRT.apply(dummyContext, new PreciseNumber("10005")).multiply(new PreciseNumber("426880"));
             NumberInterface M = PreciseNumber.ONE;
             NumberInterface L = new PreciseNumber("13591409");
             NumberInterface X = M;
@@ -165,12 +163,12 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberOperator OP_DIVIDE = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
-            return params.length == 2 && params[1].compareTo(implementation.instanceForString(Integer.toString(0))) != 0;
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
+            return params.length == 2 && params[1].compareTo(context.getInheritedNumberImplementation().instanceForString(Integer.toString(0))) != 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].divide(params[1]);
         }
     };
@@ -180,14 +178,15 @@ public class StandardPlugin extends Plugin {
     public static final NumberOperator OP_FACTORIAL = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.UNARY_POSTFIX, 0) {
         //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1
-                    && params[0].fractionalPart().compareTo(implementation.instanceForString("0")) == 0
+                    && params[0].fractionalPart().compareTo(context.getInheritedNumberImplementation().instanceForString("0")) == 0
                     && params[0].signum() >= 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             if (params[0].signum() == 0) {
                 return implementation.instanceForString("1");
             }
@@ -211,13 +210,14 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberOperator OP_NPR = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2 && params[0].fractionalPart().signum() == 0
                     && params[1].fractionalPart().signum() == 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             if (params[0].compareTo(params[1]) < 0 ||
                     params[0].signum() < 0 ||
                     (params[0].signum() == 0 && params[1].signum() != 0)) return implementation.instanceForString("0");
@@ -241,14 +241,14 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberOperator OP_NCR = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2 && params[0].fractionalPart().signum() == 0
                     && params[1].fractionalPart().signum() == 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return OP_NPR.apply(implementation, params).divide(OP_FACTORIAL.apply(implementation, params[1]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return OP_NPR.apply(context, params).divide(OP_FACTORIAL.apply(context, params[1]));
         }
     };
     /**
@@ -256,13 +256,13 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberFunction FUNCTION_ABS = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return params[0].multiply(implementation.instanceForString(Integer.toString(params[0].signum())));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return params[0].multiply(context.getInheritedNumberImplementation().instanceForString(Integer.toString(params[0].signum())));
         }
     };
     /**
@@ -270,16 +270,17 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberFunction FUNCTION_LN = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
-            return params.length == 1 && params[0].compareTo(implementation.instanceForString("0")) > 0;
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
+            return params.length == 1 && params[0].compareTo(context.getInheritedNumberImplementation().instanceForString("0")) > 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             NumberInterface param = params[0];
             NumberInterface one = implementation.instanceForString("1");
             int powersOf2 = 0;
-            while (FUNCTION_ABS.apply(implementation, param.subtract(one)).compareTo(implementation.instanceForString(".1")) >= 0) {
+            while (FUNCTION_ABS.apply(context, param.subtract(one)).compareTo(implementation.instanceForString(".1")) >= 0) {
                 if (param.subtract(one).signum() == 1) {
                     param = param.divide(implementation.instanceForString("2"));
                     powersOf2++;
@@ -296,7 +297,7 @@ public class StandardPlugin extends Plugin {
                     }
                 }
             }
-            return getLog2(implementation, param).multiply(implementation.instanceForString(Integer.toString(powersOf2))).add(getLogPartialSum(implementation, param));
+            return getLog2(context.getInheritedNumberImplementation(), param).multiply(implementation.instanceForString(Integer.toString(powersOf2))).add(getLogPartialSum(context, param));
         }
 
         /**
@@ -305,13 +306,13 @@ public class StandardPlugin extends Plugin {
          * @param x value at which the series is evaluated. 0 < x < 2. (x=2 is convergent but impractical.)
          * @return the partial sum.
          */
-        private NumberInterface getLogPartialSum(NumberImplementation implementation, NumberInterface x) {
-
+        private NumberInterface getLogPartialSum(MutableEvaluationContext context, NumberInterface x) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             NumberInterface maxError = x.getMaxError();
             x = x.subtract(implementation.instanceForString("1")); //Terms used are for log(x+1).
             NumberInterface currentNumerator = x, currentTerm = x, sum = x;
             int n = 1;
-            while (FUNCTION_ABS.apply(implementation, currentTerm).compareTo(maxError) > 0) {
+            while (FUNCTION_ABS.apply(context, currentTerm).compareTo(maxError) > 0) {
                 n++;
                 currentNumerator = currentNumerator.multiply(x).negate();
                 currentTerm = currentNumerator.divide(implementation.instanceForString(Integer.toString(n)));
@@ -331,7 +332,7 @@ public class StandardPlugin extends Plugin {
             //We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
             //In the following, a=1/3^n, b=1/4^n, c = 1/n.
             //a is also an error bound.
-            NumberInterface a = implementation.instanceForString("1"), b = a, c = a;
+            NumberInterface a = implementation.instanceForString("1"), b = a, c;
             NumberInterface sum = implementation.instanceForString("0");
             NumberInterface one = implementation.instanceForString("1");
             int n = 0;
@@ -350,13 +351,13 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberFunction FUNCTION_RAND_INT = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return implementation.instanceForString(Long.toString(Math.round(Math.random() * params[0].floor().intValue())));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return context.getInheritedNumberImplementation().instanceForString(Long.toString(Math.round(Math.random() * params[0].floor().intValue())));
         }
     };
     /**
@@ -364,8 +365,8 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberOperator OP_CARET = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2) {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
-            NumberInterface zero = implementation.instanceForString("0");
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberInterface zero = context.getInheritedNumberImplementation().instanceForString("0");
             return params.length == 2
                     && !(params[0].compareTo(zero) == 0
                     && params[1].compareTo(zero) == 0)
@@ -373,7 +374,8 @@ public class StandardPlugin extends Plugin {
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             NumberInterface zero = implementation.instanceForString("0");
             if (params[0].compareTo(zero) == 0)
                 return zero;
@@ -381,12 +383,12 @@ public class StandardPlugin extends Plugin {
                 return implementation.instanceForString("1");
             //Detect integer bases:
             if (params[0].fractionalPart().compareTo(implementation.instanceForString("0")) == 0
-                    && FUNCTION_ABS.apply(implementation, params[1]).compareTo(implementation.instanceForString(Integer.toString(Integer.MAX_VALUE))) < 0
-                    && FUNCTION_ABS.apply(implementation, params[1]).compareTo(implementation.instanceForString("1")) >= 0) {
+                    && FUNCTION_ABS.apply(context, params[1]).compareTo(implementation.instanceForString(Integer.toString(Integer.MAX_VALUE))) < 0
+                    && FUNCTION_ABS.apply(context, params[1]).compareTo(implementation.instanceForString("1")) >= 0) {
                 NumberInterface[] newParams = {params[0], params[1].fractionalPart()};
-                return params[0].intPow(params[1].floor().intValue()).multiply(applyInternal(implementation, newParams));
+                return params[0].intPow(params[1].floor().intValue()).multiply(applyInternal(context, newParams));
             }
-            return FUNCTION_EXP.apply(implementation, FUNCTION_LN.apply(implementation, FUNCTION_ABS.apply(implementation, params[0])).multiply(params[1]));
+            return FUNCTION_EXP.apply(context, FUNCTION_LN.apply(context, FUNCTION_ABS.apply(context, params[0])).multiply(params[1]));
         }
     };
     /**
@@ -394,13 +396,13 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberFunction FUNCTION_SQRT = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return OP_CARET.apply(implementation, params[0], implementation.instanceForString(".5"));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return OP_CARET.apply(context, params[0], context.getInheritedNumberImplementation().instanceForString(".5"));
         }
     };
     private static final HashMap<NumberImplementation, ArrayList<NumberInterface>> FACTORIAL_LISTS = new HashMap<>();
@@ -409,17 +411,18 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberFunction FUNCTION_EXP = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             NumberInterface maxError = params[0].getMaxError();
             int n = 0;
             if (params[0].signum() < 0) {
                 NumberInterface[] negatedParams = {params[0].negate()};
-                return implementation.instanceForString("1").divide(applyInternal(implementation, negatedParams));
+                return implementation.instanceForString("1").divide(applyInternal(context, negatedParams));
             } else {
                 //We need n such that x^(n+1) * 3^ceil(x) <= maxError * (n+1)!.
                 //right and left refer to lhs and rhs in the above inequality.
@@ -446,15 +449,16 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionSin = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             NumberInterface pi = piFor(params[0].getClass());
             NumberInterface twoPi = pi.multiply(implementation.instanceForString("2"));
-            NumberInterface theta = getSmallAngle(implementation, params[0], pi);
+            NumberInterface theta = getSmallAngle(context, params[0], pi);
             //System.out.println(theta);
             if (theta.compareTo(pi.multiply(implementation.instanceForString("1.5"))) >= 0) {
                 theta = theta.subtract(twoPi);
@@ -462,7 +466,7 @@ public class StandardPlugin extends Plugin {
                 theta = pi.subtract(theta);
             }
             //System.out.println(theta);
-            return sinTaylor(implementation, theta);
+            return sinTaylor(context, theta);
         }
     };
     /**
@@ -470,13 +474,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionCos = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return functionSin.apply(implementation, piFor(params[0].getClass()).divide(implementation.instanceForString("2"))
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return functionSin.apply(context, piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2"))
                     .subtract(params[0]));
         }
     };
@@ -485,13 +489,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionTan = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return functionSin.apply(implementation, params[0]).divide(functionCos.apply(implementation, params[0]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return functionSin.apply(context, params[0]).divide(functionCos.apply(context, params[0]));
         }
     };
     /**
@@ -499,13 +503,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionSec = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return implementation.instanceForString("1").divide(functionCos.apply(implementation, params[0]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return context.getInheritedNumberImplementation().instanceForString("1").divide(functionCos.apply(context, params[0]));
         }
     };
     /**
@@ -513,13 +517,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionCsc = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return implementation.instanceForString("1").divide(functionSin.apply(implementation, params[0]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return context.getInheritedNumberImplementation().instanceForString("1").divide(functionSin.apply(context, params[0]));
         }
     };
     /**
@@ -527,13 +531,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionCot = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return functionCos.apply(implementation, params[0]).divide(functionSin.apply(implementation, params[0]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return functionCos.apply(context, params[0]).divide(functionSin.apply(context, params[0]));
         }
     };
 
@@ -542,23 +546,24 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArcsin = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1
-                    && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) <= 0;
+                    && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) <= 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            if (FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString(".8")) >= 0) {
-                NumberInterface[] newParams = {FUNCTION_SQRT.apply(implementation, implementation.instanceForString("1").subtract(params[0].multiply(params[0])))};
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
+            if (FUNCTION_ABS.apply(context, params[0]).compareTo(implementation.instanceForString(".8")) >= 0) {
+                NumberInterface[] newParams = {FUNCTION_SQRT.apply(context, implementation.instanceForString("1").subtract(params[0].multiply(params[0])))};
                 return piFor(params[0].getClass()).divide(implementation.instanceForString("2"))
-                        .subtract(applyInternal(implementation, newParams)).multiply(implementation.instanceForString(Integer.toString(params[0].signum())));
+                        .subtract(applyInternal(context, newParams)).multiply(implementation.instanceForString(Integer.toString(params[0].signum())));
             }
             NumberInterface currentTerm = params[0], sum = currentTerm,
                     multiplier = currentTerm.multiply(currentTerm), summandBound = sum.getMaxError().multiply(implementation.instanceForString("1").subtract(multiplier)),
                     power = currentTerm, coefficient = implementation.instanceForString("1");
             int exponent = 1;
-            while (FUNCTION_ABS.apply(implementation, currentTerm).compareTo(summandBound) > 0) {
+            while (FUNCTION_ABS.apply(context, currentTerm).compareTo(summandBound) > 0) {
                 exponent += 2;
                 power = power.multiply(multiplier);
                 coefficient = coefficient.multiply(implementation.instanceForString(Integer.toString(exponent - 2)))
@@ -575,14 +580,14 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArccos = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
-            return params.length == 1 && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) <= 0;
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
+            return params.length == 1 && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) <= 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return piFor(params[0].getClass()).divide(implementation.instanceForString("2"))
-                    .subtract(functionArcsin.apply(implementation, params));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2"))
+                    .subtract(functionArcsin.apply(context, params));
         }
     };
 
@@ -591,14 +596,14 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArccsc = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
-            return params.length == 1 && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) >= 0;
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
+            return params.length == 1 && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) >= 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            NumberInterface[] reciprocalParamArr = {implementation.instanceForString("1").divide(params[0])};
-            return functionArcsin.apply(implementation, reciprocalParamArr);
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberInterface[] reciprocalParamArr = {context.getInheritedNumberImplementation().instanceForString("1").divide(params[0])};
+            return functionArcsin.apply(context, reciprocalParamArr);
         }
     };
 
@@ -607,14 +612,14 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArcsec = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
-            return params.length == 1 && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) >= 0;
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
+            return params.length == 1 && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) >= 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            NumberInterface[] reciprocalParamArr = {implementation.instanceForString("1").divide(params[0])};
-            return functionArccos.apply(implementation, reciprocalParamArr);
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberInterface[] reciprocalParamArr = {context.getInheritedNumberImplementation().instanceForString("1").divide(params[0])};
+            return functionArccos.apply(context, reciprocalParamArr);
         }
     };
 
@@ -623,20 +628,21 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArctan = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             if (params[0].signum() == -1) {
                 NumberInterface[] negatedParams = {params[0].negate()};
-                return applyInternal(implementation, negatedParams).negate();
+                return applyInternal(context, negatedParams).negate();
             }
             if (params[0].compareTo(implementation.instanceForString("1")) > 0) {
                 NumberInterface[] reciprocalParams = {implementation.instanceForString("1").divide(params[0])};
                 return piFor(params[0].getClass()).divide(implementation.instanceForString("2"))
-                        .subtract(applyInternal(implementation, reciprocalParams));
+                        .subtract(applyInternal(context, reciprocalParams));
             }
             if (params[0].compareTo(implementation.instanceForString("1")) == 0) {
                 return piFor(params[0].getClass()).divide(implementation.instanceForString("4"));
@@ -644,12 +650,12 @@ public class StandardPlugin extends Plugin {
             if (params[0].compareTo(implementation.instanceForString(".9")) >= 0) {
                 NumberInterface[] newParams = {params[0].multiply(implementation.instanceForString("2"))
                         .divide(implementation.instanceForString("1").subtract(params[0].multiply(params[0])))};
-                return applyInternal(implementation, newParams).divide(implementation.instanceForString("2"));
+                return applyInternal(context, newParams).divide(implementation.instanceForString("2"));
             }
             NumberInterface currentPower = params[0], currentTerm = currentPower, sum = currentTerm,
                     maxError = params[0].getMaxError(), multiplier = currentPower.multiply(currentPower).negate();
             int n = 1;
-            while (FUNCTION_ABS.apply(implementation, currentTerm).compareTo(maxError) > 0) {
+            while (FUNCTION_ABS.apply(context, currentTerm).compareTo(maxError) > 0) {
                 n += 2;
                 currentPower = currentPower.multiply(multiplier);
                 currentTerm = currentPower.divide(implementation.instanceForString(Integer.toString(n)));
@@ -664,14 +670,14 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArccot = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-            return piFor(params[0].getClass()).divide(implementation.instanceForString("2"))
-                    .subtract(functionArctan.apply(implementation, params));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2"))
+                    .subtract(functionArctan.apply(context, params));
         }
     };
 
@@ -687,8 +693,7 @@ public class StandardPlugin extends Plugin {
      * @param n              non-negative integer.
      * @return a number of numClass with value n factorial.
      */
-    public static NumberInterface factorial(NumberImplementation implementation, int n) {
-
+    synchronized public static NumberInterface factorial(NumberImplementation implementation, int n) {
         if (!FACTORIAL_LISTS.containsKey(implementation)) {
             FACTORIAL_LISTS.put(implementation, new ArrayList<>());
             FACTORIAL_LISTS.get(implementation).add(implementation.instanceForString("1"));
@@ -709,16 +714,16 @@ public class StandardPlugin extends Plugin {
      * @param x where the series is evaluated.
      * @return the value of the series
      */
-    private static NumberInterface sinTaylor(NumberImplementation implementation, NumberInterface x) {
-        NumberInterface power = x, multiplier = x.multiply(x).negate(), currentTerm = x, sum = x;
+    private static NumberInterface sinTaylor(MutableEvaluationContext context, NumberInterface x) {
+        NumberInterface power = x, multiplier = x.multiply(x).negate(), currentTerm, sum = x;
         NumberInterface maxError = x.getMaxError();
         int n = 1;
         do {
             n += 2;
             power = power.multiply(multiplier);
-            currentTerm = power.divide(factorial(implementation, n));
+            currentTerm = power.divide(factorial(context.getInheritedNumberImplementation(), n));
             sum = sum.add(currentTerm);
-        } while (FUNCTION_ABS.apply(implementation, currentTerm).compareTo(maxError) > 0);
+        } while (FUNCTION_ABS.apply(context, currentTerm).compareTo(maxError) > 0);
         return sum;
     }
 
@@ -728,10 +733,10 @@ public class StandardPlugin extends Plugin {
      * @param phi an angle (in radians).
      * @return theta in [0, 2pi) that differs from phi by a multiple of 2pi.
      */
-    private static NumberInterface getSmallAngle(NumberImplementation implementation, NumberInterface phi, NumberInterface pi) {
-        NumberInterface twoPi = pi.multiply(implementation.instanceForString("2"));
-        NumberInterface theta = FUNCTION_ABS.apply(implementation, phi).subtract(twoPi
-                .multiply(FUNCTION_ABS.apply(implementation, phi).divide(twoPi).floor())); //Now theta is in [0, 2pi).
+    private static NumberInterface getSmallAngle(MutableEvaluationContext context, NumberInterface phi, NumberInterface pi) {
+        NumberInterface twoPi = pi.multiply(context.getInheritedNumberImplementation().instanceForString("2"));
+        NumberInterface theta = FUNCTION_ABS.apply(context, phi).subtract(twoPi
+                .multiply(FUNCTION_ABS.apply(context, phi).divide(twoPi).floor())); //Now theta is in [0, 2pi).
         if (phi.signum() < 0) {
             theta = twoPi.subtract(theta);
         }

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

@@ -1,93 +0,0 @@
-package org.nwapw.abacus.tree;
-
-import org.nwapw.abacus.Abacus;
-import org.nwapw.abacus.function.NumberFunction;
-import org.nwapw.abacus.function.NumberOperator;
-import org.nwapw.abacus.function.TreeValueFunction;
-import org.nwapw.abacus.function.TreeValueOperator;
-import org.nwapw.abacus.number.NumberInterface;
-import org.nwapw.abacus.number.PromotionManager;
-import org.nwapw.abacus.number.PromotionResult;
-import org.nwapw.abacus.variables.VariableDatabase;
-
-/**
- * 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) {
-        PromotionManager manager = abacus.getPromotionManager();
-        if (node instanceof NumberNode) {
-            return abacus.getNumberImplementation().instanceForString(((NumberNode) node).getNumber());
-        } else if (node instanceof VariableNode) {
-            VariableDatabase database = abacus.getVariableDatabase();
-            String name = ((VariableNode) node).getVariable();
-            NumberInterface variable = database.getVariables().get(name);
-            if(variable != null) return variable;
-            TreeNode definition = database.getDefinitions().get(name);
-            if(definition != null) return definition.reduce(this);
-            return abacus.getNumberImplementation().instanceForString("0");
-        } else if (node instanceof NumberBinaryNode) {
-            NumberInterface left = (NumberInterface) children[0];
-            NumberInterface right = (NumberInterface) children[1];
-            NumberOperator operator = abacus.getPluginManager().operatorFor(((BinaryNode) node).getOperation());
-            PromotionResult result = manager.promote(left, right);
-            if (result == null) return null;
-            return operator.apply(result.getPromotedTo(), result.getItems());
-        } else if (node instanceof NumberUnaryNode) {
-            NumberInterface child = (NumberInterface) children[0];
-            NumberOperator operator = abacus.getPluginManager().operatorFor(((UnaryNode) node).getOperation());
-            return operator.apply(abacus.getPluginManager().interfaceImplementationFor(child.getClass()), 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];
-            }
-            NumberFunction function = abacus.getPluginManager().functionFor(((FunctionNode) node).getCallTo());
-            if (function == null) return null;
-            PromotionResult result = manager.promote(convertedChildren);
-            if (result == null) return null;
-            return function.apply(result.getPromotedTo(), result.getItems());
-        } else if (node instanceof TreeValueFunctionNode) {
-            CallNode callNode = (CallNode) node;
-            TreeNode[] realChildren = new TreeNode[callNode.getChildren().size()];
-            for (int i = 0; i < realChildren.length; i++) {
-                realChildren[i] = callNode.getChildren().get(i);
-            }
-            TreeValueFunction function =
-                    abacus.getPluginManager().treeValueFunctionFor(callNode.getCallTo());
-            if (function == null) return null;
-            return function.applyWithReducer(abacus.getNumberImplementation(), this, realChildren);
-        } else if (node instanceof TreeValueBinaryNode) {
-            BinaryNode binaryNode = (BinaryNode) node;
-            TreeValueOperator operator = abacus.getPluginManager()
-                    .treeValueOperatorFor(binaryNode.getOperation());
-            if (operator == null) return null;
-            return operator.applyWithReducer(abacus.getNumberImplementation(), this, binaryNode.getLeft(), binaryNode.getRight());
-        } else if (node instanceof TreeValueUnaryNode) {
-            UnaryNode unaryNode = (UnaryNode) node;
-            TreeValueOperator operator = abacus.getPluginManager()
-                    .treeValueOperatorFor(unaryNode.getOperation());
-            if (operator == null) return null;
-            return operator.applyWithReducer(abacus.getNumberImplementation(), this, unaryNode.getApplyTo());
-        }
-        return null;
-    }
-
-}

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

@@ -1,17 +1,17 @@
 package org.nwapw.abacus
 
 import org.nwapw.abacus.config.Configuration
-import org.nwapw.abacus.number.NumberInterface
+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.NumberImplementation
 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
-import org.nwapw.abacus.variables.VariableDatabase
 
 /**
  * Core class to handle all mathematics.
@@ -36,10 +36,6 @@ class Abacus(val configuration: Configuration) {
      * The plugin manager used to handle loading and unloading plugins.
      */
     val pluginManager = PluginManager(this)
-    /**
-     * The reducer used to turn trees into a single number.
-     */
-    val numberReducer = NumberReducer(this)
     /**
      * The tree builder that handles the conversion of strings into trees.
      */
@@ -48,28 +44,43 @@ class Abacus(val configuration: Configuration) {
      * The promotion manager used to convert between number implementations.
      */
     val promotionManager = PromotionManager(this)
+
     /**
-     * The database of variable definitions.
+     * The hidden, mutable implementation of the context.
      */
-    val variableDatabase = VariableDatabase(this)
+    private val mutableContext = MutableEvaluationContext(numberImplementation = StandardPlugin.IMPLEMENTATION_NAIVE)
     /**
-     * The number implementation used by default.
+     * The base context from which calculations are started.
      */
-    val numberImplementation: NumberImplementation
-        get() {
-            val selectedImplementation =
-                    pluginManager.numberImplementationFor(configuration.numberImplementation)
-            if (selectedImplementation != null) return selectedImplementation
-            return StandardPlugin.IMPLEMENTATION_NAIVE
-        }
+    val context: EvaluationContext
+        get() = mutableContext
 
     init {
         pluginManager.addListener(tokenizer)
         pluginManager.addListener(parser)
         pluginManager.addListener(promotionManager)
-        pluginManager.addListener(variableDatabase)
     }
 
+    /**
+     * 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.
@@ -77,14 +88,28 @@ class Abacus(val configuration: Configuration) {
      * @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)
+    fun parseString(input: String): TreeNode = treeBuilder.fromString(input)
     /**
-     * Evaluates the given tree using the main
-     * number reducer.
+     * Evaluates the given tree.
      *
      * @param tree the tree to reduce, must not be null.
-     * @return the resulting number, or null of the reduction failed.
+     * @return the evaluation result.
      */
-    fun evaluateTree(tree: TreeNode): NumberInterface? = tree.reduce(numberReducer)
+    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/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/TreeValueFunction.kt

@@ -1,6 +1,6 @@
 package org.nwapw.abacus.function
 
-import org.nwapw.abacus.function.applicable.ReducerApplicable
+import org.nwapw.abacus.function.applicable.Applicable
 import org.nwapw.abacus.number.NumberInterface
 import org.nwapw.abacus.tree.TreeNode
 
@@ -10,4 +10,4 @@ import org.nwapw.abacus.tree.TreeNode
  * 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 : ReducerApplicable<TreeNode, NumberInterface, NumberInterface>
+abstract class TreeValueFunction : Applicable<TreeNode, NumberInterface>

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

@@ -1,6 +1,6 @@
 package org.nwapw.abacus.function
 
-import org.nwapw.abacus.function.applicable.ReducerApplicable
+import org.nwapw.abacus.function.applicable.Applicable
 import org.nwapw.abacus.number.NumberInterface
 import org.nwapw.abacus.tree.TreeNode
 
@@ -15,4 +15,4 @@ import org.nwapw.abacus.tree.TreeNode
 abstract class TreeValueOperator(associativity: OperatorAssociativity, type: OperatorType,
                                  precedence: Int) :
         Operator(associativity, type, precedence),
-        ReducerApplicable<TreeNode, NumberInterface, NumberInterface>
+        Applicable<TreeNode, NumberInterface>

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

@@ -1,7 +1,7 @@
 package org.nwapw.abacus.function.applicable
 
-import org.nwapw.abacus.function.DomainException
-import org.nwapw.abacus.plugin.NumberImplementation
+import org.nwapw.abacus.context.MutableEvaluationContext
+import org.nwapw.abacus.exception.DomainException
 
 /**
  * A class that can be applied to arguments.
@@ -18,7 +18,7 @@ interface Applicable<in T : Any, out O : Any> {
      * @param params the parameter array to verify for compatibility.
      * @return whether the array can be used with applyInternal.
      */
-    fun matchesParams(implementation: NumberImplementation, params: Array<out T>): Boolean
+    fun matchesParams(context: MutableEvaluationContext, params: Array<out T>): Boolean
 
     /**
      * Applies the applicable object to the given parameters,
@@ -26,7 +26,7 @@ interface Applicable<in T : Any, out O : Any> {
      * @param params the parameters to apply to.
      * @return the result of the application.
      */
-    fun applyInternal(implementation: NumberImplementation, params: Array<out T>): O
+    fun applyInternal(context: MutableEvaluationContext, params: Array<out T>): O
 
     /**
      * If the parameters can be used with this applicable, returns
@@ -35,9 +35,10 @@ interface Applicable<in T : Any, out O : Any> {
      * @param params the parameters to apply to.
      * @return the result of the operation, or null if parameters do not match.
      */
-    fun apply(implementation: NumberImplementation, vararg params: T): O {
-        if (!matchesParams(implementation, params)) throw DomainException()
-        return applyInternal(implementation, params)
+    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/function/applicable/ReducerApplicable.kt

@@ -1,45 +0,0 @@
-package org.nwapw.abacus.function.applicable
-
-import org.nwapw.abacus.function.DomainException
-import org.nwapw.abacus.plugin.NumberImplementation
-import org.nwapw.abacus.tree.Reducer
-
-/**
- * Applicable that requires a reducer.
- *
- * ReducerApplicable slightly more specific Applicable that requires a reducer
- * to be passed to it along with the parameters.
- * @param <T> the type of the input arguments.
- * @param <O> the return type of the application.
- * @param <R> the required type of the reducer.
- */
-interface ReducerApplicable<in T : Any, out O : Any, in R : Any> {
-
-    /**
-     * Checks if this applicable can be applied to the
-     * given parameters.
-     * @param params the parameters to check.
-     */
-    fun matchesParams(implementation: NumberImplementation, params: Array<out T>): Boolean
-
-    /**
-     * Applies this applicable to the given arguments, and reducer.
-     * @param reducer the reducer to use in the application.
-     * @param params the arguments to apply to.
-     * @return the result of the application.
-     */
-    fun applyWithReducerInternal(implementation: NumberImplementation, reducer: Reducer<R>, params: Array<out T>): O
-
-    /**
-     * Applies this applicable to the given arguments, and reducer,
-     * if the arguments and reducer are compatible with this applicable.
-     * @param reducer the reducer to use in the application.
-     * @param params the arguments to apply to.
-     * @return the result of the application, or null if the arguments are incompatible.
-     */
-    fun applyWithReducer(implementation: NumberImplementation, reducer: Reducer<R>, vararg params: T): O {
-        if (!matchesParams(implementation, params)) throw DomainException()
-        return applyWithReducerInternal(implementation, reducer, 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/PromotionManager.kt

@@ -1,6 +1,7 @@
 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
@@ -37,21 +38,6 @@ class PromotionManager(val abacus: Abacus) : PluginListener {
         return null
     }
 
-    /**
-     * If a path between the given implementations has already been computed, uses
-     * the already calculated path. Otherwise, calls [computePathBetween] to compute a new
-     * path.
-     *
-     * @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 getPathBetween(from: NumberImplementation, to: NumberImplementation): PromotionPath? {
-        return computePaths.computeIfAbsent(from to to, {
-             computePathBetween(it.first, it.second)
-        })
-    }
-
     /**
      * 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
@@ -60,22 +46,30 @@ class PromotionManager(val abacus: Abacus) : PluginListener {
      * @param numbers the numbers to promote.
      * @return the resulting promotion result.
      */
-    fun promote(vararg numbers: NumberInterface): PromotionResult? {
+    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 getPathBetween(pluginManager.interfaceImplementationFor(it.javaClass), highestPriority)
-                    ?.promote(it) ?: return null
+            else computePaths[pluginManager.interfaceImplementationFor(it.javaClass) to highestPriority]
+                    ?.promote(it) ?: throw PromotionException()
         }.toTypedArray(), promotedTo = highestPriority)
     }
 
-    override fun onLoad(manager: PluginManager?) {
-
+    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?) {
+    override fun onUnload(manager: PluginManager) {
         computePaths.clear()
     }
 

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

@@ -11,10 +11,10 @@ package org.nwapw.abacus.tree
  * @param left the left node.
  * @param right the right node.
  */
-abstract class BinaryNode(val operation: String, val left: TreeNode? = null, val right: TreeNode?) : TreeNode() {
+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

@@ -7,13 +7,9 @@ package org.nwapw.abacus.tree
  * 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) : TreeNode() {
-
-    /**
-     * The list of children this node has.
-     */
-    val children: MutableList<TreeNode> = mutableListOf()
+abstract class CallNode(val callTo: String, val children: List<TreeNode>) : TreeNode() {
 
     override fun toString(): String {
         val buffer = StringBuffer()

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,10 +8,10 @@ package org.nwapw.abacus.tree
  *
  * @param function the function string.
  */
-class FunctionNode(function: String) : CallNode(function) {
+class FunctionNode(function: String, children: List<TreeNode>) : CallNode(function, children) {
 
-    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)
     }
 

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

@@ -10,12 +10,12 @@ package org.nwapw.abacus.tree
  * @param left the left child of this node.
  * @param right the right child of this node.
  */
-class NumberBinaryNode(operation: String, left: TreeNode?, right: TreeNode?)
+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) ?: return null
-        val right = right?.reduce(reducer) ?: return null
+    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

@@ -10,7 +10,7 @@ package org.nwapw.abacus.tree
  */
 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)
     }
 

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

@@ -8,11 +8,11 @@ package org.nwapw.abacus.tree
  * @param operation the operation this node performs.
  * @param child the child this node should be applied to.
  */
-class NumberUnaryNode(operation: String, child: TreeNode?)
+class NumberUnaryNode(operation: String, child: TreeNode)
     : UnaryNode(operation, child) {
 
-    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
-        val child = applyTo?.reduce(reducer) ?: return null
+    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

@@ -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

@@ -11,10 +11,10 @@ package org.nwapw.abacus.tree
  * @param left the left child of this node.
  * @param right the right child of this node.
  */
-class TreeValueBinaryNode(operation: String, left: TreeNode?, right: TreeNode?)
+class TreeValueBinaryNode(operation: String, left: TreeNode, right: TreeNode)
     : BinaryNode(operation, left, right) {
 
-    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
         return reducer.reduceNode(this)
     }
 

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

@@ -7,9 +7,9 @@ package org.nwapw.abacus.tree
  * is mostly to help the reducer. Besides that, this class also does not
  * even attempt to reduce its children.
  */
-class TreeValueFunctionNode(name: String) : CallNode(name) {
+class TreeValueFunctionNode(name: String, children: List<TreeNode>) : CallNode(name, children) {
 
-    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
         return reducer.reduceNode(this)
     }
 

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

@@ -9,11 +9,11 @@ package org.nwapw.abacus.tree
  * @param operation the operation this node performs.
  * @param child the node the operation should be applied to.
  */
-class TreeValueUnaryNode(operation: String, child: TreeNode?)
+class TreeValueUnaryNode(operation: String, child: TreeNode)
     : UnaryNode(operation, child) {
 
-    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
-        return reducer.reduceNode(this);
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
+        return reducer.reduceNode(this)
     }
 
 }

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

@@ -9,10 +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.
  */
-abstract class UnaryNode(val operation: String, val applyTo: TreeNode? = null) : TreeNode() {
+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

@@ -10,7 +10,7 @@ package org.nwapw.abacus.tree
  */
 class VariableNode(val variable: String) : TreeNode() {
 
-    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
+    override fun <T : Any> reduce(reducer: Reducer<T>): T {
         return reducer.reduceNode(this)
     }
 

core/src/main/kotlin/org/nwapw/abacus/variables/VariableDatabase.kt

@@ -1,37 +0,0 @@
-package org.nwapw.abacus.variables
-
-import org.nwapw.abacus.Abacus
-import org.nwapw.abacus.number.NumberInterface
-import org.nwapw.abacus.plugin.PluginListener
-import org.nwapw.abacus.plugin.PluginManager
-import org.nwapw.abacus.tree.TreeNode
-
-/**
- * A database for variables and definition.
- *
- * The variable database is used to keep track of
- * variables and definitions throughout the calculator.
- *
- * @property abacus the Abacus instance.
- */
-class VariableDatabase(val abacus: Abacus): PluginListener {
-
-    /**
-     * The variables that are stored in the database.
-     */
-    val variables = mutableMapOf<String, NumberInterface>()
-    /**
-     * The definitions that are stored in the database.
-     */
-    val definitions = mutableMapOf<String, TreeNode>()
-
-    override fun onLoad(manager: PluginManager?) {
-
-    }
-
-    override fun onUnload(manager: PluginManager?) {
-        variables.clear()
-        definitions.clear()
-    }
-
-}

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

@@ -5,7 +5,7 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.config.Configuration;
-import org.nwapw.abacus.function.DomainException;
+import org.nwapw.abacus.exception.DomainException;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.plugin.StandardPlugin;
 import org.nwapw.abacus.tree.TreeNode;
@@ -17,21 +17,19 @@ public class CalculationTests {
     @BeforeClass
     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) {
         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 testDomainException(String input, String parseOutput) {
         TreeNode parsedTree = abacus.parseString(input);
-        Assert.assertNotNull(parsedTree);
         Assert.assertEquals(parsedTree.toString(), parseOutput);
         try {
             abacus.evaluateTree(parsedTree);

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,11 +5,11 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.config.Configuration;
+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;
-import org.nwapw.abacus.plugin.NumberImplementation;
 import org.nwapw.abacus.plugin.Plugin;
 import org.nwapw.abacus.tree.TokenType;
 
@@ -21,12 +21,12 @@ public class TokenizerTests {
     private static LexerTokenizer lexerTokenizer = new LexerTokenizer();
     private static NumberFunction subtractFunction = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].subtract(params[1]);
         }
     };
@@ -37,26 +37,26 @@ public class TokenizerTests {
                     0) {
 
                 @Override
-                public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+                public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
                     return true;
                 }
 
                                 @Override
-                public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-                    return subtractFunction.apply(implementation, params);
+                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(NumberImplementation implementation, NumberInterface[] params) {
+                public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
                     return true;
                 }
 
                                 @Override
-                public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
-                    return subtractFunction.apply(implementation, params);
+                public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+                    return subtractFunction.apply(context, params);
                 }
             });
             registerFunction("subtract", subtractFunction);
@@ -80,7 +80,7 @@ public class TokenizerTests {
     public static void prepareTests() {
         abacus.getPluginManager().addListener(lexerTokenizer);
         abacus.getPluginManager().addInstantiated(testPlugin);
-        abacus.getPluginManager().load();
+        abacus.reload();
     }
 
     @Test

fx/build.gradle

@@ -2,7 +2,14 @@ apply plugin: 'application'
 
 dependencies {
     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/AbacusController.java

@@ -12,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.function.DomainException;
 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;
@@ -141,19 +142,13 @@ public class AbacusController implements PluginListener {
         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 (DomainException exception) {
+            } catch (AbacusException exception) {
                 return exception.getMessage();
             } catch (RuntimeException exception) {
                 exception.printStackTrace();
@@ -320,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
@@ -360,7 +355,12 @@ 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)));

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"/>