Do not use null in exceptions and add messages to exceptions.

Fix exception during startup if configuration is missing.

core/build.gradle

@@ -1,4 +1,3 @@
 dependencies {
-    compile 'com.moandjiezana.toml:toml4j:0.7.1'
     testCompile 'junit:junit:4.12'
 }

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

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

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

@@ -1,159 +0,0 @@
-package org.nwapw.abacus.config;
-
-import com.moandjiezana.toml.Toml;
-import com.moandjiezana.toml.TomlWriter;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * The configuration object that stores
- * options that the user can change.
- */
-public class Configuration {
-
-    /**
-     * The defaults TOML string.
-     */
-    private static final String DEFAULT_CONFIG =
-            "numberImplementation = \"naive\"\n" +
-                    "disabledPlugins = []";
-    /**
-     * The defaults TOML object, parsed from the string.
-     */
-    private static final Toml DEFAULT_TOML = new Toml().read(DEFAULT_CONFIG);
-    /**
-     * The TOML writer used to write this configuration to a file.
-     */
-    private static final TomlWriter TOML_WRITER = new TomlWriter();
-
-    /**
-     * The computation delay for which the thread can run without interruption.
-     */
-    private double computationDelay = 0;
-    /**
-     * The implementation of the number that should be used.
-     */
-    private String numberImplementation = "<default>";
-    /**
-     * The list of disabled plugins in this Configuration.
-     */
-    private Set<String> disabledPlugins = new HashSet<>();
-
-    /**
-     * Creates a new configuration form the given configuration.
-     *
-     * @param copyFrom the configuration to copy.
-     */
-    public Configuration(Configuration copyFrom) {
-        copyFrom(copyFrom);
-    }
-
-    /**
-     * Creates a new configuration with the given values.
-     *
-     * @param computationDelay     the delay before the computation gets killed.
-     * @param numberImplementation the number implementation, like "naive" or "precise"
-     * @param disabledPlugins      the list of disabled plugins.
-     */
-    public Configuration(double computationDelay, String numberImplementation, String[] disabledPlugins) {
-        this.computationDelay = computationDelay;
-        this.numberImplementation = numberImplementation;
-        this.disabledPlugins.addAll(Arrays.asList(disabledPlugins));
-    }
-
-    /**
-     * Loads a configuration from a given file, keeping non-specified fields default.
-     *
-     * @param fromFile the file to load from.
-     */
-    public Configuration(File fromFile) {
-        if (!fromFile.exists()) return;
-        copyFrom(new Toml(DEFAULT_TOML).read(fromFile).to(Configuration.class));
-    }
-
-    /**
-     * Copies the values from the given configuration into this one.
-     *
-     * @param otherConfiguration the configuration to copy from.
-     */
-    public void copyFrom(Configuration otherConfiguration) {
-        this.computationDelay = otherConfiguration.computationDelay;
-        this.numberImplementation = otherConfiguration.numberImplementation;
-        this.disabledPlugins.addAll(otherConfiguration.disabledPlugins);
-    }
-
-    /**
-     * Saves this configuration to the given file, creating
-     * any directories that do not exist.
-     *
-     * @param file the file to save to.
-     */
-    public void saveTo(File file) {
-        if (file.getParentFile() != null) file.getParentFile().mkdirs();
-        try {
-            TOML_WRITER.write(this, file);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    /**
-     * Gets the value of this configuration as a string.
-     *
-     * @return the string that represents this configuration.
-     */
-    public String asTomlString() {
-        return TOML_WRITER.write(this);
-    }
-
-    /**
-     * Gets the number implementation from this configuration.
-     *
-     * @return the number implementation.
-     */
-    public String getNumberImplementation() {
-        return numberImplementation;
-    }
-
-    /**
-     * Sets the number implementation for the configuration
-     *
-     * @param numberImplementation the number implementation.
-     */
-    public void setNumberImplementation(String numberImplementation) {
-        this.numberImplementation = numberImplementation;
-    }
-
-    /**
-     * Gets the list of disabled plugins.
-     *
-     * @return the list of disabled plugins.
-     */
-    public Set<String> getDisabledPlugins() {
-        return disabledPlugins;
-    }
-
-
-    /**
-     * Gets the computation delay specified in the configuration.
-     *
-     * @return the computaton delay.
-     */
-    public double getComputationDelay() {
-        return computationDelay;
-    }
-
-    /**
-     * Sets the computation delay.
-     *
-     * @param computationDelay the new computation delay.
-     */
-    public void setComputationDelay(double computationDelay) {
-        this.computationDelay = computationDelay;
-    }
-
-}

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

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

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

@@ -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/DomainException.java

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

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

@@ -0,0 +1,25 @@
+package org.nwapw.abacus.exception;
+
+/**
+ * An exception thrown primarily from Tree Value operators and functions,
+ * which have to deal with the result of a Reducer as well as the results
+ * of Applicable.
+ */
+public class EvaluationException extends AbacusException {
+
+    /**
+     * Creates a new EvaluationException with the default string.
+     */
+    public EvaluationException() {
+        this("");
+    }
+
+    /**
+     * Creates a new EvaluationError with the given message string.
+     * @param message the message string.
+     */
+    public EvaluationException(String message) {
+        super("Evaluation error", message);
+    }
+
+}

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

@@ -114,15 +114,6 @@ public class NaiveNumber extends NumberInterface {
         return (int) value;
     }
 
-    @Override
-    public NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass) {
-        if (toClass == this.getClass()) return this;
-        else if (toClass == PreciseNumber.class) {
-            return new PreciseNumber(Double.toString(value));
-        }
-        return null;
-    }
-
     public String toString() {
         double shiftBy = Math.pow(10, 10);
         return Double.toString(Math.round(value * shiftBy) / shiftBy);

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

@@ -1,5 +1,7 @@
 package org.nwapw.abacus.number;
 
+import org.nwapw.abacus.exception.ComputationInterruptedException;
+
 /**
  * An interface used to represent a number.
  */
@@ -236,29 +238,6 @@ public abstract class NumberInterface {
      */
     public abstract int intValue();
 
-    /**
-     * Promotes this class to another number class.
-     *
-     * @param toClass the class to promote to.
-     * @return the resulting new instance.
-     */
-    @Deprecated
-    protected abstract NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass);
-
-    /**
-     * Promotes this class to another number class. Also, checks if the
-     * thread has been interrupted, and if so, throws
-     * an exception.
-     *
-     * @param toClass the class to promote to.
-     * @return the resulting new instance.
-     */
-    @Deprecated
-    public final NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
-        checkInterrupted();
-        return promoteToInternal(toClass);
-    }
-
     /**
      * Returns the smallest error this instance can tolerate depending
      * on its precision and value.

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

@@ -152,14 +152,6 @@ public class PreciseNumber extends NumberInterface {
         return new PreciseNumber(value.negate());
     }
 
-    @Override
-    public NumberInterface promoteToInternal(Class<? extends NumberInterface> toClass) {
-        if (toClass == this.getClass()) {
-            return this;
-        }
-        return null;
-    }
-
     @Override
     public String toString() {
         return value.round(outputContext).toString();

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

@@ -50,13 +50,13 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
         for (String operator : manager.getAllOperators()) {
             lexer.register(Pattern.sanitize(operator), TokenType.OP);
         }
-        for (String operator : manager.getAllTreeValueOperators()){
+        for (String operator : manager.getAllTreeValueOperators()) {
             lexer.register(Pattern.sanitize(operator), TokenType.TREE_VALUE_OP);
         }
         for (String function : manager.getAllFunctions()) {
             lexer.register(Pattern.sanitize(function), TokenType.FUNCTION);
         }
-        for (String function : manager.getAllTreeValueFunctions()){
+        for (String function : manager.getAllTreeValueFunctions()) {
             lexer.register(Pattern.sanitize(function), TokenType.TREE_VALUE_FUNCTION);
         }
     }
@@ -66,13 +66,13 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
         for (String operator : manager.getAllOperators()) {
             lexer.unregister(Pattern.sanitize(operator), TokenType.OP);
         }
-        for (String operator : manager.getAllTreeValueOperators()){
+        for (String operator : manager.getAllTreeValueOperators()) {
             lexer.unregister(Pattern.sanitize(operator), TokenType.TREE_VALUE_OP);
         }
         for (String function : manager.getAllFunctions()) {
             lexer.unregister(Pattern.sanitize(function), TokenType.FUNCTION);
         }
-        for (String function : manager.getAllTreeValueFunctions()){
+        for (String function : manager.getAllTreeValueFunctions()) {
             lexer.unregister(Pattern.sanitize(function), TokenType.TREE_VALUE_FUNCTION);
         }
     }

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

@@ -134,7 +134,7 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                 TreeNode right = constructRecursive(matches);
                 TreeNode left = constructRecursive(matches);
                 if (left == null || right == null) return null;
-                if(matchType == TokenType.OP) {
+                if (matchType == TokenType.OP) {
                     return new NumberBinaryNode(operator, left, right);
                 } else {
                     return new TreeValueBinaryNode(operator, left, right);
@@ -142,7 +142,7 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             } else {
                 TreeNode applyTo = constructRecursive(matches);
                 if (applyTo == null) return null;
-                if(matchType == TokenType.OP){
+                if (matchType == TokenType.OP) {
                     return new NumberUnaryNode(operator, applyTo);
                 } else {
                     return new TreeValueUnaryNode(operator, applyTo);
@@ -154,19 +154,20 @@ 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;
             matches.remove(0);
+            CallNode node;
+            if (matchType == TokenType.FUNCTION) {
+                node = new FunctionNode(functionName, children);
+            } else {
+                node = new TreeValueFunctionNode(functionName, children);
+            }
             return node;
         }
         return null;

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

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

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

@@ -49,10 +49,13 @@ public class PluginManager {
      */
     private Set<Documentation> registeredDocumentation;
     /**
-     * The list of number implementations that have been
-     * found by their implementation class.
+     * The list of number implementation names.
      */
-    private Map<Class<? extends NumberInterface>, NumberImplementation> cachedInterfaceImplementations;
+    private Map<Class<? extends NumberInterface>, String> interfaceImplementationNames;
+    /**
+     * The list of number implementations.
+     */
+    private Map<Class<? extends NumberInterface>, NumberImplementation> interfaceImplementations;
     /**
      * The pi values for each implementation class that have already been computer.
      */
@@ -82,7 +85,8 @@ public class PluginManager {
         registeredTreeValueOperators = new HashMap<>();
         registeredNumberImplementations = new HashMap<>();
         registeredDocumentation = new HashSet<>();
-        cachedInterfaceImplementations = new HashMap<>();
+        interfaceImplementations = new HashMap<>();
+        interfaceImplementationNames = new HashMap<>();
         cachedPi = new HashMap<>();
         listeners = new HashSet<>();
     }
@@ -135,6 +139,8 @@ public class PluginManager {
      */
     public void registerNumberImplementation(String name, NumberImplementation implementation) {
         registeredNumberImplementations.put(name, implementation);
+        interfaceImplementationNames.put(implementation.getImplementation(), name);
+        interfaceImplementations.put(implementation.getImplementation(), implementation);
     }
 
     /**
@@ -226,17 +232,17 @@ public class PluginManager {
      * @return the implementation.
      */
     public NumberImplementation interfaceImplementationFor(Class<? extends NumberInterface> name) {
-        if (cachedInterfaceImplementations.containsKey(name)) return cachedInterfaceImplementations.get(name);
-        NumberImplementation toReturn = null;
-        for (String key : registeredNumberImplementations.keySet()) {
-            NumberImplementation implementation = registeredNumberImplementations.get(key);
-            if (implementation.getImplementation() == name) {
-                toReturn = implementation;
-                break;
-            }
-        }
-        cachedInterfaceImplementations.put(name, toReturn);
-        return toReturn;
+        return interfaceImplementations.get(name);
+    }
+
+    /**
+     * Gets the number implementation name for the given implementation class.
+     *
+     * @param name the class for which to find the implementation name.
+     * @return the implementation name.
+     */
+    public String interfaceImplementationNameFor(Class<? extends NumberInterface> name) {
+        return interfaceImplementationNames.get(name);
     }
 
     /**
@@ -329,7 +335,8 @@ public class PluginManager {
         registeredTreeValueOperators.clear();
         registeredNumberImplementations.clear();
         registeredDocumentation.clear();
-        cachedInterfaceImplementations.clear();
+        interfaceImplementationNames.clear();
+        interfaceImplementations.clear();
         cachedPi.clear();
         listeners.forEach(e -> e.onUnload(this));
     }
@@ -414,4 +421,5 @@ public class PluginManager {
     public Set<Class<?>> getLoadedPluginClasses() {
         return loadedPluginClasses;
     }
+    
 }

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

@@ -1,13 +1,15 @@
 package org.nwapw.abacus.plugin;
 
+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.TreeNode;
+import org.nwapw.abacus.tree.VariableNode;
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.function.BiFunction;
 
 /**
  * The plugin providing standard functions such as addition and subtraction to
@@ -15,17 +17,50 @@ import java.util.function.BiFunction;
  */
 public class StandardPlugin extends Plugin {
 
+    /**
+     * The set operator.
+     */
+    public final TreeValueOperator opSet = new TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
+        @Override
+        public boolean matchesParams(MutableEvaluationContext context, TreeNode[] params) {
+            return params.length == 2 && params[0] instanceof VariableNode;
+        }
+
+        @Override
+        public NumberInterface applyInternal(MutableEvaluationContext context, TreeNode[] params) {
+            String assignTo = ((VariableNode) params[0]).getVariable();
+            NumberInterface value = params[1].reduce(context.getInheritedReducer());
+            context.setVariable(assignTo, value);
+            return value;
+        }
+    };
+    /**
+     * The define operator.
+     */
+    public final TreeValueOperator opDefine = new TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
+        @Override
+        public boolean matchesParams(MutableEvaluationContext context, TreeNode[] params) {
+            return params.length == 2 && params[0] instanceof VariableNode;
+        }
+
+        @Override
+        public NumberInterface applyInternal(MutableEvaluationContext context, TreeNode[] params) {
+            String assignTo = ((VariableNode) params[0]).getVariable();
+            context.setDefinition(assignTo, params[1]);
+            return params[1].reduce(context.getInheritedReducer());
+        }
+    };
     /**
      * The addition operator, +
      */
     public static final NumberOperator OP_ADD = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].add(params[1]);
         }
     };
@@ -34,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(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].subtract(params[1]);
 
         }
@@ -49,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(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].negate();
         }
     };
@@ -63,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(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].multiply(params[1]);
         }
     };
@@ -86,20 +121,6 @@ public class StandardPlugin extends Plugin {
             return new NaiveNumber(Math.PI);
         }
     };
-    /**
-     * The square root function.
-     */
-    public static final NumberFunction FUNCTION_SQRT = new NumberFunction() {
-        @Override
-        public boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1;
-        }
-
-        @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            return OP_CARET.apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
-        }
-    };
     /**
      * The implementation for the infinite-precision BigDecimal.
      */
@@ -111,7 +132,8 @@ public class StandardPlugin extends Plugin {
 
         @Override
         public NumberInterface instanceForPi() {
-            NumberInterface C = FUNCTION_SQRT.apply(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;
@@ -136,21 +158,17 @@ public class StandardPlugin extends Plugin {
             return C.divide(sum);
         }
     };
-    /**
-     * Stores objects of NumberInterface with integer values for reuse.
-     */
-    private final static HashMap<Class<? extends NumberInterface>, HashMap<Integer, NumberInterface>> integerValues = new HashMap<>();
     /**
      * The division operator, /
      */
     public static final NumberOperator OP_DIVIDE = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1) {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
-            return params.length == 2 && params[1].compareTo(fromInt(params[0].getClass(), 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(NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
             return params[0].divide(params[1]);
         }
     };
@@ -160,18 +178,19 @@ 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(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1
-                    && params[0].fractionalPart().compareTo(fromInt(params[0].getClass(), 0)) == 0
+                    && params[0].fractionalPart().compareTo(context.getInheritedNumberImplementation().instanceForString("0")) == 0
                     && params[0].signum() >= 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             if (params[0].signum() == 0) {
-                return fromInt(params[0].getClass(), 1);
+                return implementation.instanceForString("1");
             }
-            NumberInterface one = fromInt(params[0].getClass(), 1);
+            NumberInterface one = implementation.instanceForString("1");
             NumberInterface factorial = params[0];
             NumberInterface multiplier = params[0];
             //It is necessary to later prevent calls of factorial on anything but non-negative integers.
@@ -191,27 +210,28 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberOperator OP_NPR = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        public boolean matchesParams(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(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 fromInt(params[0].getClass(), 0);
-            NumberInterface total = fromInt(params[0].getClass(), 1);
+                    (params[0].signum() == 0 && params[1].signum() != 0)) return implementation.instanceForString("0");
+            NumberInterface total = implementation.instanceForString("1");
             NumberInterface multiplyBy = params[0];
             NumberInterface remainingMultiplications = params[1];
-            NumberInterface halfway = params[0].divide(fromInt(params[0].getClass(), 2));
+            NumberInterface halfway = params[0].divide(implementation.instanceForString("2"));
             if (remainingMultiplications.compareTo(halfway) > 0) {
                 remainingMultiplications = params[0].subtract(remainingMultiplications);
             }
             while (remainingMultiplications.signum() > 0) {
                 total = total.multiply(multiplyBy);
-                remainingMultiplications = remainingMultiplications.subtract(fromInt(params[0].getClass(), 1));
-                multiplyBy = multiplyBy.subtract(fromInt(params[0].getClass(), 1));
+                remainingMultiplications = remainingMultiplications.subtract(implementation.instanceForString("1"));
+                multiplyBy = multiplyBy.subtract(implementation.instanceForString("1"));
             }
             return total;
         }
@@ -221,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(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(NumberInterface[] params) {
-            return OP_NPR.apply(params).divide(OP_FACTORIAL.apply(params[1]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return OP_NPR.apply(context, params).divide(OP_FACTORIAL.apply(context, params[1]));
         }
     };
     /**
@@ -236,13 +256,13 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberFunction FUNCTION_ABS = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            return params[0].multiply(fromInt(params[0].getClass(), params[0].signum()));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return params[0].multiply(context.getInheritedNumberImplementation().instanceForString(Integer.toString(params[0].signum())));
         }
     };
     /**
@@ -250,25 +270,26 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberFunction FUNCTION_LN = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1 && params[0].compareTo(fromInt(params[0].getClass(), 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(NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             NumberInterface param = params[0];
-            NumberInterface one = fromInt(param.getClass(), 1);
+            NumberInterface one = implementation.instanceForString("1");
             int powersOf2 = 0;
-            while (FUNCTION_ABS.apply(param.subtract(one)).compareTo(new NaiveNumber(0.1).promoteTo(param.getClass())) >= 0) {
+            while (FUNCTION_ABS.apply(context, param.subtract(one)).compareTo(implementation.instanceForString(".1")) >= 0) {
                 if (param.subtract(one).signum() == 1) {
-                    param = param.divide(fromInt(param.getClass(), 2));
+                    param = param.divide(implementation.instanceForString("2"));
                     powersOf2++;
                     if (param.subtract(one).signum() != 1) {
                         break;
                         //No infinite loop for you.
                     }
                 } else {
-                    param = param.multiply(fromInt(param.getClass(), 2));
+                    param = param.multiply(implementation.instanceForString("2"));
                     powersOf2--;
                     if (param.subtract(one).signum() != -1) {
                         break;
@@ -276,7 +297,7 @@ public class StandardPlugin extends Plugin {
                     }
                 }
             }
-            return getLog2(param).multiply(fromInt(param.getClass(), powersOf2)).add(getLogPartialSum(param));
+            return getLog2(context.getInheritedNumberImplementation(), param).multiply(implementation.instanceForString(Integer.toString(powersOf2))).add(getLogPartialSum(context, param));
         }
 
         /**
@@ -285,16 +306,16 @@ 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(NumberInterface x) {
-
+        private NumberInterface getLogPartialSum(MutableEvaluationContext context, NumberInterface x) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             NumberInterface maxError = x.getMaxError();
-            x = x.subtract(fromInt(x.getClass(), 1)); //Terms used are for log(x+1).
+            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(currentTerm).compareTo(maxError) > 0) {
+            while (FUNCTION_ABS.apply(context, currentTerm).compareTo(maxError) > 0) {
                 n++;
                 currentNumerator = currentNumerator.multiply(x).negate();
-                currentTerm = currentNumerator.divide(fromInt(x.getClass(), n));
+                currentTerm = currentNumerator.divide(implementation.instanceForString(Integer.toString(n)));
                 sum = sum.add(currentTerm);
             }
             return sum;
@@ -305,21 +326,21 @@ public class StandardPlugin extends Plugin {
          * @param number a number of the same type as the return type. (Used for precision.)
          * @return the value of log(2) with the appropriate precision.
          */
-        private NumberInterface getLog2(NumberInterface number) {
+        private NumberInterface getLog2(NumberImplementation implementation, NumberInterface number) {
             NumberInterface maxError = number.getMaxError();
-            //NumberInterface errorBound = fromInt(number.getClass(), 1);
+            //NumberInterface errorBound = implementation.instanceForString("1");
             //We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
             //In the following, a=1/3^n, b=1/4^n, c = 1/n.
             //a is also an error bound.
-            NumberInterface a = fromInt(number.getClass(), 1), b = a, c = a;
-            NumberInterface sum = fromInt(number.getClass(), 0);
-            NumberInterface one = fromInt(number.getClass(), 1);
+            NumberInterface a = implementation.instanceForString("1"), b = a, c = a;
+            NumberInterface sum = implementation.instanceForString("0");
+            NumberInterface one = implementation.instanceForString("1");
             int n = 0;
             while (a.compareTo(maxError) >= 1) {
                 n++;
-                a = a.divide(fromInt(number.getClass(), 3));
-                b = b.divide(fromInt(number.getClass(), 4));
-                c = one.divide(fromInt(number.getClass(), n));
+                a = a.divide(implementation.instanceForString("3"));
+                b = b.divide(implementation.instanceForString("4"));
+                c = one.divide(implementation.instanceForString(Integer.toString(n)));
                 sum = sum.add(a.add(b).multiply(c));
             }
             return sum;
@@ -330,44 +351,90 @@ public class StandardPlugin extends Plugin {
      */
     public static final NumberFunction FUNCTION_RAND_INT = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            return fromInt(params[0].getClass(), (int) 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())));
         }
     };
-    private static final HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> FACTORIAL_LISTS = new HashMap<>();
+    /**
+     * The caret / pow operator, ^
+     */
+    public static final NumberOperator OP_CARET = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2) {
+        @Override
+        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)
+                    && !(params[0].signum() == -1 && params[1].fractionalPart().compareTo(zero) != 0);
+        }
+
+        @Override
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
+            NumberInterface zero = implementation.instanceForString("0");
+            if (params[0].compareTo(zero) == 0)
+                return zero;
+            else if (params[1].compareTo(zero) == 0)
+                return implementation.instanceForString("1");
+            //Detect integer bases:
+            if (params[0].fractionalPart().compareTo(implementation.instanceForString("0")) == 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(context, newParams));
+            }
+            return FUNCTION_EXP.apply(context, FUNCTION_LN.apply(context, FUNCTION_ABS.apply(context, params[0])).multiply(params[1]));
+        }
+    };
+    /**
+     * The square root function.
+     */
+    public static final NumberFunction FUNCTION_SQRT = new NumberFunction() {
+        @Override
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        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<>();
     /**
      * The exponential function, exp(1) = e^1 = 2.71...
      */
     public static final NumberFunction FUNCTION_EXP = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(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 fromInt(params[0].getClass(), 1).divide(applyInternal(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.
-                NumberInterface sum = fromInt(params[0].getClass(), 1);
+                NumberInterface sum = implementation.instanceForString("1");
                 NumberInterface nextNumerator = params[0];
-                NumberInterface left = params[0].multiply(fromInt(params[0].getClass(), 3).intPow(params[0].ceiling().intValue())), right = maxError;
+                NumberInterface left = params[0].multiply(implementation.instanceForString("3").intPow(params[0].ceiling().intValue())), right = maxError;
                 do {
-                    sum = sum.add(nextNumerator.divide(factorial(params[0].getClass(), n + 1)));
+                    sum = sum.add(nextNumerator.divide(factorial(implementation, n + 1)));
                     n++;
                     nextNumerator = nextNumerator.multiply(params[0]);
                     left = left.multiply(params[0]);
-                    NumberInterface nextN = fromInt(params[0].getClass(), n + 1);
+                    NumberInterface nextN = implementation.instanceForString(Integer.toString(n + 1));
                     right = right.multiply(nextN);
                     //System.out.println(left + ", " + right);
                 }
@@ -377,58 +444,29 @@ public class StandardPlugin extends Plugin {
             }
         }
     };
-    /**
-     * The caret / pow operator, ^
-     */
-    public static final NumberOperator OP_CARET = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2) {
-        @Override
-        public boolean matchesParams(NumberInterface[] params) {
-            NumberInterface zero = fromInt(params[0].getClass(), 0);
-            return params.length == 2
-                    && !(params[0].compareTo(zero) == 0
-                    && params[1].compareTo(zero) == 0)
-                    && !(params[0].signum() == -1 && params[1].fractionalPart().compareTo(zero) != 0);
-        }
-
-        @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            NumberInterface zero = fromInt(params[0].getClass(), 0);
-            if (params[0].compareTo(zero) == 0)
-                return zero;
-            else if (params[1].compareTo(zero) == 0)
-                return fromInt(params[0].getClass(), 1);
-            //Detect integer bases:
-            if (params[0].fractionalPart().compareTo(fromInt(params[0].getClass(), 0)) == 0
-                    && FUNCTION_ABS.apply(params[1]).compareTo(fromInt(params[0].getClass(), Integer.MAX_VALUE)) < 0
-                    && FUNCTION_ABS.apply(params[1]).compareTo(fromInt(params[1].getClass(), 1)) >= 0) {
-                NumberInterface[] newParams = {params[0], params[1].fractionalPart()};
-                return params[0].intPow(params[1].floor().intValue()).multiply(applyInternal(newParams));
-            }
-            return FUNCTION_EXP.apply(FUNCTION_LN.apply(FUNCTION_ABS.apply(params[0])).multiply(params[1]));
-        }
-    };
     /**
      * The sine function (the argument is interpreted in radians).
      */
     public final NumberFunction functionSin = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberImplementation implementation = context.getInheritedNumberImplementation();
             NumberInterface pi = piFor(params[0].getClass());
-            NumberInterface twoPi = pi.multiply(fromInt(pi.getClass(), 2));
-            NumberInterface theta = getSmallAngle(params[0], pi);
+            NumberInterface twoPi = pi.multiply(implementation.instanceForString("2"));
+            NumberInterface theta = getSmallAngle(context, params[0], pi);
             //System.out.println(theta);
-            if (theta.compareTo(pi.multiply(new NaiveNumber(1.5).promoteTo(twoPi.getClass()))) >= 0) {
+            if (theta.compareTo(pi.multiply(implementation.instanceForString("1.5"))) >= 0) {
                 theta = theta.subtract(twoPi);
-            } else if (theta.compareTo(pi.divide(fromInt(pi.getClass(), 2))) > 0) {
+            } else if (theta.compareTo(pi.divide(implementation.instanceForString("2"))) > 0) {
                 theta = pi.subtract(theta);
             }
             //System.out.println(theta);
-            return sinTaylor(theta);
+            return sinTaylor(context, theta);
         }
     };
     /**
@@ -436,13 +474,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionCos = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            return functionSin.apply(piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return functionSin.apply(context, piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2"))
                     .subtract(params[0]));
         }
     };
@@ -451,13 +489,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionTan = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            return functionSin.apply(params[0]).divide(functionCos.apply(params[0]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return functionSin.apply(context, params[0]).divide(functionCos.apply(context, params[0]));
         }
     };
     /**
@@ -465,13 +503,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionSec = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            return fromInt(params[0].getClass(), 1).divide(functionCos.apply(params[0]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return context.getInheritedNumberImplementation().instanceForString("1").divide(functionCos.apply(context, params[0]));
         }
     };
     /**
@@ -479,13 +517,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionCsc = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            return fromInt(params[0].getClass(), 1).divide(functionSin.apply(params[0]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return context.getInheritedNumberImplementation().instanceForString("1").divide(functionSin.apply(context, params[0]));
         }
     };
     /**
@@ -493,13 +531,13 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionCot = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            return functionCos.apply(params[0]).divide(functionSin.apply(params[0]));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return functionCos.apply(context, params[0]).divide(functionSin.apply(context, params[0]));
         }
     };
 
@@ -508,28 +546,29 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArcsin = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1
-                    && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 1)) <= 0;
+                    && FUNCTION_ABS.apply(context, params[0]).compareTo(context.getInheritedNumberImplementation().instanceForString("1")) <= 0;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            if (FUNCTION_ABS.apply(params[0]).compareTo(new NaiveNumber(0.8).promoteTo(params[0].getClass())) >= 0) {
-                NumberInterface[] newParams = {FUNCTION_SQRT.apply(fromInt(params[0].getClass(), 1).subtract(params[0].multiply(params[0])))};
-                return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
-                        .subtract(applyInternal(newParams)).multiply(fromInt(params[0].getClass(), params[0].signum()));
+        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(context, newParams)).multiply(implementation.instanceForString(Integer.toString(params[0].signum())));
             }
             NumberInterface currentTerm = params[0], sum = currentTerm,
-                    multiplier = currentTerm.multiply(currentTerm), summandBound = sum.getMaxError().multiply(fromInt(sum.getClass(), 1).subtract(multiplier)),
-                    power = currentTerm, coefficient = fromInt(params[0].getClass(), 1);
+                    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(currentTerm).compareTo(summandBound) > 0) {
+            while (FUNCTION_ABS.apply(context, currentTerm).compareTo(summandBound) > 0) {
                 exponent += 2;
                 power = power.multiply(multiplier);
-                coefficient = coefficient.multiply(fromInt(params[0].getClass(), exponent - 2))
-                        .divide(fromInt(params[0].getClass(), exponent - 1));
-                currentTerm = power.multiply(coefficient).divide(fromInt(power.getClass(), exponent));
+                coefficient = coefficient.multiply(implementation.instanceForString(Integer.toString(exponent - 2)))
+                        .divide(implementation.instanceForString(Integer.toString(exponent - 1)));
+                currentTerm = power.multiply(coefficient).divide(implementation.instanceForString(Integer.toString(exponent)));
                 sum = sum.add(currentTerm);
             }
             return sum;
@@ -541,14 +580,14 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArccos = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1 && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 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(NumberInterface[] params) {
-            return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
-                    .subtract(functionArcsin.apply(params));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2"))
+                    .subtract(functionArcsin.apply(context, params));
         }
     };
 
@@ -557,14 +596,14 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArccsc = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1 && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 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(NumberInterface[] params) {
-            NumberInterface[] reciprocalParamArr = {fromInt(params[0].getClass(), 1).divide(params[0])};
-            return functionArcsin.apply(reciprocalParamArr);
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberInterface[] reciprocalParamArr = {context.getInheritedNumberImplementation().instanceForString("1").divide(params[0])};
+            return functionArcsin.apply(context, reciprocalParamArr);
         }
     };
 
@@ -573,14 +612,14 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArcsec = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1 && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 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(NumberInterface[] params) {
-            NumberInterface[] reciprocalParamArr = {fromInt(params[0].getClass(), 1).divide(params[0])};
-            return functionArccos.apply(reciprocalParamArr);
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            NumberInterface[] reciprocalParamArr = {context.getInheritedNumberImplementation().instanceForString("1").divide(params[0])};
+            return functionArccos.apply(context, reciprocalParamArr);
         }
     };
 
@@ -589,36 +628,37 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArctan = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(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(negatedParams).negate();
+                return applyInternal(context, negatedParams).negate();
             }
-            if (params[0].compareTo(fromInt(params[0].getClass(), 1)) > 0) {
-                NumberInterface[] reciprocalParams = {fromInt(params[0].getClass(), 1).divide(params[0])};
-                return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
-                        .subtract(applyInternal(reciprocalParams));
+            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(context, reciprocalParams));
             }
-            if (params[0].compareTo(fromInt(params[0].getClass(), 1)) == 0) {
-                return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 4));
+            if (params[0].compareTo(implementation.instanceForString("1")) == 0) {
+                return piFor(params[0].getClass()).divide(implementation.instanceForString("4"));
             }
-            if (params[0].compareTo(new NaiveNumber(0.9).promoteTo(params[0].getClass())) >= 0) {
-                NumberInterface[] newParams = {params[0].multiply(fromInt(params[0].getClass(), 2))
-                        .divide(fromInt(params[0].getClass(), 1).subtract(params[0].multiply(params[0])))};
-                return applyInternal(newParams).divide(fromInt(params[0].getClass(), 2));
+            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(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(currentTerm).compareTo(maxError) > 0) {
+            while (FUNCTION_ABS.apply(context, currentTerm).compareTo(maxError) > 0) {
                 n += 2;
                 currentPower = currentPower.multiply(multiplier);
-                currentTerm = currentPower.divide(fromInt(currentPower.getClass(), n));
+                currentTerm = currentPower.divide(implementation.instanceForString(Integer.toString(n)));
                 sum = sum.add(currentTerm);
             }
             return sum;
@@ -630,14 +670,14 @@ public class StandardPlugin extends Plugin {
      */
     public final NumberFunction functionArccot = new NumberFunction() {
         @Override
-        public boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(MutableEvaluationContext context, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        public NumberInterface applyInternal(NumberInterface[] params) {
-            return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
-                    .subtract(functionArctan.apply(params));
+        public NumberInterface applyInternal(MutableEvaluationContext context, NumberInterface[] params) {
+            return piFor(params[0].getClass()).divide(context.getInheritedNumberImplementation().instanceForString("2"))
+                    .subtract(functionArctan.apply(context, params));
         }
     };
 
@@ -645,40 +685,25 @@ public class StandardPlugin extends Plugin {
         super(manager);
     }
 
-    /**
-     * Returns a partial sum of a series whose terms are given by the nthTermFunction, evaluated at x.
-     *
-     * @param x               the value at which the series is evaluated.
-     * @param nthTermFunction the function that returns the nth term of the series, in the format term(x, n).
-     * @param n               the number of terms in the partial sum.
-     * @return the value of the partial sum that has the same class as x.
-     */
-    private static NumberInterface sumSeries(NumberInterface x, BiFunction<Integer, NumberInterface, NumberInterface> nthTermFunction, int n) {
-        NumberInterface sum = fromInt(x.getClass(), 0);
-        for (int i = 0; i <= n; i++) {
-            sum = sum.add(nthTermFunction.apply(i, x));
-        }
-        return sum;
-    }
-
     /**
      * A factorial function that uses memoization for each number class; it efficiently
      * computes factorials of non-negative integers.
      *
-     * @param numberClass type of number to return.
-     * @param n           non-negative integer.
+     * @param implementation type of number to return.
+     * @param n              non-negative integer.
      * @return a number of numClass with value n factorial.
      */
-    public static NumberInterface factorial(Class<? extends NumberInterface> numberClass, int n) {
-        if (!FACTORIAL_LISTS.containsKey(numberClass)) {
-            FACTORIAL_LISTS.put(numberClass, new ArrayList<>());
-            FACTORIAL_LISTS.get(numberClass).add(fromInt(numberClass, 1));
-            FACTORIAL_LISTS.get(numberClass).add(fromInt(numberClass, 1));
+    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"));
+            FACTORIAL_LISTS.get(implementation).add(implementation.instanceForString("1"));
         }
-        ArrayList<NumberInterface> list = FACTORIAL_LISTS.get(numberClass);
+        ArrayList<NumberInterface> list = FACTORIAL_LISTS.get(implementation);
         if (n >= list.size()) {
             while (list.size() < n + 16) {
-                list.add(list.get(list.size() - 1).multiply(fromInt(numberClass, list.size())));
+                list.add(list.get(list.size() - 1).multiply(implementation.instanceForString(Integer.toString(list.size()))));
             }
         }
         return list.get(n);
@@ -690,16 +715,16 @@ public class StandardPlugin extends Plugin {
      * @param x where the series is evaluated.
      * @return the value of the series
      */
-    private static NumberInterface sinTaylor(NumberInterface x) {
+    private static NumberInterface sinTaylor(MutableEvaluationContext context, NumberInterface x) {
         NumberInterface power = x, multiplier = x.multiply(x).negate(), currentTerm = x, sum = x;
         NumberInterface maxError = x.getMaxError();
         int n = 1;
         do {
             n += 2;
             power = power.multiply(multiplier);
-            currentTerm = power.divide(factorial(x.getClass(), n));
+            currentTerm = power.divide(factorial(context.getInheritedNumberImplementation(), n));
             sum = sum.add(currentTerm);
-        } while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0);
+        } while (FUNCTION_ABS.apply(context, currentTerm).compareTo(maxError) > 0);
         return sum;
     }
 
@@ -709,33 +734,16 @@ 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(NumberInterface phi, NumberInterface pi) {
-        NumberInterface twoPi = pi.multiply(fromInt(pi.getClass(), 2));
-        NumberInterface theta = FUNCTION_ABS.apply(phi).subtract(twoPi
-                .multiply(FUNCTION_ABS.apply(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);
         }
         return theta;
     }
 
-    /**
-     * Returns a number of class numType with value n.
-     *
-     * @param numType class of number to return.
-     * @param n       value of returned number.
-     * @return numClass instance with value n.
-     */
-    private static NumberInterface fromInt(Class<? extends NumberInterface> numType, int n) {
-        if (!integerValues.containsKey(numType)) {
-            integerValues.put(numType, new HashMap<>());
-        }
-        if (!integerValues.get(numType).containsKey(n)) {
-            integerValues.get(numType).put(n, new NaiveNumber(n).promoteTo(numType));
-        }
-        return integerValues.get(numType).get(n);
-    }
-
     @Override
     public void onEnable() {
         registerNumberImplementation("naive", IMPLEMENTATION_NAIVE);
@@ -749,6 +757,9 @@ public class StandardPlugin extends Plugin {
         registerOperator("^", OP_CARET);
         registerOperator("!", OP_FACTORIAL);
 
+        registerTreeValueOperator("=", opSet);
+        registerTreeValueOperator(":=", opDefine);
+
         registerOperator("nPr", OP_NPR);
         registerOperator("nCr", OP_NCR);
 
@@ -824,6 +835,6 @@ public class StandardPlugin extends Plugin {
 
     @Override
     public void onDisable() {
-
+        FACTORIAL_LISTS.clear();
     }
 }

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

@@ -1,76 +0,0 @@
-package org.nwapw.abacus.tree;
-
-import org.nwapw.abacus.Abacus;
-import org.nwapw.abacus.function.*;
-import org.nwapw.abacus.number.NumberInterface;
-
-/**
- * A reducer implementation that turns a tree into a single number.
- * This is not always guaranteed to work.
- */
-public class NumberReducer implements Reducer<NumberInterface> {
-
-    /**
-     * The plugin manager from which to draw the functions.
-     */
-    private Abacus abacus;
-
-    /**
-     * Creates a new number reducer.
-     *
-     * @param abacus the calculator instance.
-     */
-    public NumberReducer(Abacus abacus) {
-        this.abacus = abacus;
-    }
-
-    @Override
-    public NumberInterface reduceNode(TreeNode node, Object... children) {
-        if (node instanceof NumberNode) {
-            return abacus.numberFromString(((NumberNode) node).getNumber());
-        } else if(node instanceof VariableNode) {
-            return abacus.numberFromString("0");
-        } else if (node instanceof NumberBinaryNode) {
-            NumberInterface left = (NumberInterface) children[0];
-            NumberInterface right = (NumberInterface) children[1];
-            NumberOperator operator = abacus.getPluginManager().operatorFor(((BinaryNode) node).getOperation());
-            return operator.apply(left, right);
-        } else if (node instanceof NumberUnaryNode) {
-            NumberInterface child = (NumberInterface) children[0];
-            NumberOperator operator = abacus.getPluginManager().operatorFor(((UnaryNode) node).getOperation());
-            return operator.apply(child);
-        } else if (node instanceof FunctionNode) {
-            NumberInterface[] convertedChildren = new NumberInterface[children.length];
-            for (int i = 0; i < convertedChildren.length; i++) {
-                convertedChildren[i] = (NumberInterface) children[i];
-            }
-            NumberFunction function = abacus.getPluginManager().functionFor(((FunctionNode) node).getCallTo());
-            if (function == null) return null;
-            return function.apply(convertedChildren);
-        } 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(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(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(this, unaryNode.getApplyTo());
-        }
-        return null;
-    }
-
-}

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+package org.nwapw.abacus.context
+
+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 ?: return null
+        var returnedValue = currentRef.valueGetter()
+        while (returnedValue == null) {
+            currentRef = currentRef.parent ?: break
+            returnedValue = currentRef.valueGetter()
+        }
+        return returnedValue
+    }
+
+}

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,5 +1,8 @@
 package org.nwapw.abacus.function.applicable
 
+import org.nwapw.abacus.context.MutableEvaluationContext
+import org.nwapw.abacus.exception.DomainException
+
 /**
  * A class that can be applied to arguments.
  *
@@ -15,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(params: Array<out T>): Boolean
+    fun matchesParams(context: MutableEvaluationContext, params: Array<out T>): Boolean
 
     /**
      * Applies the applicable object to the given parameters,
@@ -23,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(params: Array<out T>): O?
+    fun applyInternal(context: MutableEvaluationContext, params: Array<out T>): O
 
     /**
      * If the parameters can be used with this applicable, returns
@@ -32,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(vararg params: T): O? {
-        if (!matchesParams(params)) return null
-        return applyInternal(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,43 +0,0 @@
-package org.nwapw.abacus.function.applicable
-
-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(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(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(reducer: Reducer<R>, vararg params: T): O? {
-        if (!matchesParams(params)) return null
-        return applyWithReducerInternal(reducer, params)
-    }
-
-}

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

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

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

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

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

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

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

@@ -11,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,67 @@
+package org.nwapw.abacus.tree
+
+import org.nwapw.abacus.Abacus
+import org.nwapw.abacus.context.EvaluationContext
+import org.nwapw.abacus.exception.EvaluationException
+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)
+                        ?: throw EvaluationException("no number implementation selected.")
+            }
+            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 EvaluationException("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) ?:
+                        throw EvaluationException("promotion failed.")
+                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()) ?:
+                        throw EvaluationException("promotion failed.")
+                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 EvaluationException("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/test/java/org/nwapw/abacus/tests/CalculationTests.java

@@ -5,34 +5,38 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.config.Configuration;
+import org.nwapw.abacus.exception.DomainException;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.plugin.StandardPlugin;
 import org.nwapw.abacus.tree.TreeNode;
 
 public class CalculationTests {
 
-    private static Abacus abacus = new Abacus(new Configuration(0, "precise", new String[]{}));
+    private static Abacus abacus = new Abacus(new Configuration( "precise", new String[]{}));
 
     @BeforeClass
     public static void prepareTests() {
         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 testEvalError(String input, String parseOutput) {
+    private void testDomainException(String input, String parseOutput) {
         TreeNode parsedTree = abacus.parseString(input);
         Assert.assertNotNull(parsedTree);
         Assert.assertEquals(parsedTree.toString(), parseOutput);
-        Assert.assertNull(abacus.evaluateTree(parsedTree));
+        try {
+            abacus.evaluateTree(parsedTree);
+            Assert.fail("Function did not throw DomainException.");
+        } catch (DomainException e){ }
     }
 
     @Test
@@ -73,7 +77,7 @@ public class CalculationTests {
 
     @Test
     public void testLn() {
-        testEvalError("ln(-1)", "ln((1)`)");
+        testDomainException("ln(-1)", "ln((1)`)");
         testOutput("ln2", "ln(2)", "0.6931471805599453094172321214581765680755");
     }
 
@@ -100,8 +104,8 @@ public class CalculationTests {
         testOutput("2^-1", "(2^(1)`)", "0.5");
         testOutput("2^50", "(2^50)", "112589990684262");
         testOutput("7^(-sqrt2*17)", "(7^((sqrt(2)*17))`)", "4.81354609155297814551845300063563");
-        testEvalError("0^0", "(0^0)");
-        testEvalError("(-13)^.9999", "((13)`^.9999)");
+        testDomainException("0^0", "(0^0)");
+        testDomainException("(-13)^.9999", "((13)`^.9999)");
     }
 
 }

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

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

docs/_layouts/home.html

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

docs/assets/css/main.scss

@@ -7,7 +7,7 @@ $code-color: #efefef;
 $accent-color: #00AFE8;
 $clear-color: white;
 $title-font: "Open Sans";
-$text-font: Helvetica;
+$text-font: "Raleway";
 $code-font: "Source Code Pro";
 $max-width: 850px;
 

fx/build.gradle

@@ -1,6 +1,7 @@
 apply plugin: 'application'
 
 dependencies {
+    compile 'com.moandjiezana.toml:toml4j:0.7.1'
     compile project(':core')
 }
 

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

@@ -12,14 +12,18 @@ 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.exception.ComputationInterruptedException;
 import org.nwapw.abacus.function.Documentation;
 import org.nwapw.abacus.function.DocumentationType;
-import org.nwapw.abacus.number.ComputationInterruptedException;
-import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.exception.DomainException;
+import org.nwapw.abacus.exception.EvaluationException;
+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;
@@ -144,15 +148,14 @@ public class AbacusController implements PluginListener {
                 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 (AbacusException exception) {
+                return exception.getMessage();
             } catch (RuntimeException exception) {
                 exception.printStackTrace();
                 return ERR_EXCEPTION;
@@ -195,7 +198,7 @@ public class AbacusController implements PluginListener {
      */
     private final Runnable TIMER_RUNNABLE = () -> {
         try {
-            Configuration abacusConfig = abacus.getConfiguration();
+            ExtendedConfiguration abacusConfig = (ExtendedConfiguration) abacus.getConfiguration();
             if (abacusConfig.getComputationDelay() == 0) return;
             Thread.sleep((long) (abacusConfig.getComputationDelay() * 1000));
             performStop();
@@ -255,12 +258,12 @@ public class AbacusController implements PluginListener {
             if (oldValue.equals(settingsTab)) alertIfApplyNeeded(true);
         });
 
-        abacus = new Abacus(new Configuration(CONFIG_FILE));
+        abacus = new Abacus(new ExtendedConfiguration(CONFIG_FILE));
         PluginManager abacusPluginManager = abacus.getPluginManager();
         abacusPluginManager.addListener(this);
         performScan();
 
-        computationLimitField.setText(Double.toString(abacus.getConfiguration().getComputationDelay()));
+        computationLimitField.setText(Double.toString(((ExtendedConfiguration) abacus.getConfiguration()).getComputationDelay()));
         computationLimitField.textProperty().addListener((observable, oldValue, newValue) -> {
             if (!newValue.matches("(\\d+(\\.\\d*)?)?")) {
                 computationLimitField.setText(oldValue);
@@ -318,13 +321,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
@@ -337,8 +340,8 @@ public class AbacusController implements PluginListener {
             if (!pluginEntry.isEnabled()) disabledPlugins.add(pluginEntry.getClassName());
         }
         if (computationLimitField.getText().matches("\\d*(\\.\\d+)?") && computationLimitField.getText().length() != 0)
-            configuration.setComputationDelay(Double.parseDouble(computationLimitField.getText()));
-        configuration.saveTo(CONFIG_FILE);
+            ((ExtendedConfiguration) configuration).setComputationDelay(Double.parseDouble(computationLimitField.getText()));
+        ((ExtendedConfiguration) configuration).saveTo(CONFIG_FILE);
         changesMade = false;
         reloadAlertShown = false;
     }

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

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

fx/src/main/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"/>