Merge branch 'master' into website-update

Refactor configuration

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(this);
-        treeBuilder = new TreeBuilder<>(lexerTokenizer, shuntingYardParser);
-
-        pluginManager.addListener(shuntingYardParser);
-        pluginManager.addListener(lexerTokenizer);
-    }
-
-    /**
-     * Gets the current tree builder.
-     *
-     * @return the main tree builder in this abacus instance.
-     */
-    public TreeBuilder getTreeBuilder() {
-        return treeBuilder;
-    }
-
-    /**
-     * Gets the current plugin manager,
-     *
-     * @return the plugin manager in this abacus instance.
-     */
-    public PluginManager getPluginManager() {
-        return pluginManager;
-    }
-
-    /**
-     * Get the reducer that is responsible for transforming
-     * an expression into a number.
-     *
-     * @return the number reducer in this abacus instance.
-     */
-    public NumberReducer getNumberReducer() {
-        return numberReducer;
-    }
-
-    /**
-     * Gets the configuration object associated with this instance.
-     *
-     * @return the configuration object.
-     */
-    public Configuration getConfiguration() {
-        return configuration;
-    }
-
-    /**
-     * Parses a string into a tree structure using the main
-     * tree builder.
-     *
-     * @param input the input string to parse
-     * @return the resulting tree, null if the tree builder or the produced tree are null.
-     */
-    public TreeNode parseString(String input) {
-        return treeBuilder.fromString(input);
-    }
-
-    /**
-     * Evaluates the given tree using the main
-     * number reducer.
-     *
-     * @param tree the tree to reduce, must not be null.
-     * @return the resulting number, or null of the reduction failed.
-     */
-    public NumberInterface evaluateTree(TreeNode tree) {
-        return tree.reduce(numberReducer);
-    }
-
-    /**
-     * Creates a number from a string.
-     *
-     * @param numberString the string to create the number from.
-     * @return the resulting number.
-     */
-    public NumberInterface numberFromString(String numberString) {
-        NumberImplementation toInstantiate =
-                pluginManager.numberImplementationFor(configuration.getNumberImplementation());
-        if (toInstantiate == null) toInstantiate = DEFAULT_IMPLEMENTATION;
-
-        return toInstantiate.instanceForString(numberString);
-    }
-}

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

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

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

@@ -6,6 +6,6 @@ package org.nwapw.abacus.function;
  */
 public enum DocumentationType {
 
-    FUNCTION
+    FUNCTION, TREE_VALUE_FUNCTION
 
 }

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

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

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

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

core/src/main/java/org/nwapw/abacus/number/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

@@ -236,29 +236,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

@@ -34,6 +34,7 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
             register(" ", TokenType.WHITESPACE);
             register(",", TokenType.COMMA);
             register("[0-9]*(\\.[0-9]+)?", TokenType.NUM);
+            register("[a-zA-Z]+", TokenType.VARIABLE);
             register("\\(", TokenType.OPEN_PARENTH);
             register("\\)", TokenType.CLOSE_PARENTH);
         }};
@@ -49,9 +50,15 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
         for (String operator : manager.getAllOperators()) {
             lexer.register(Pattern.sanitize(operator), TokenType.OP);
         }
+        for (String operator : manager.getAllTreeValueOperators()) {
+            lexer.register(Pattern.sanitize(operator), TokenType.TREE_VALUE_OP);
+        }
         for (String function : manager.getAllFunctions()) {
             lexer.register(Pattern.sanitize(function), TokenType.FUNCTION);
         }
+        for (String function : manager.getAllTreeValueFunctions()) {
+            lexer.register(Pattern.sanitize(function), TokenType.TREE_VALUE_FUNCTION);
+        }
     }
 
     @Override
@@ -59,9 +66,15 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
         for (String operator : manager.getAllOperators()) {
             lexer.unregister(Pattern.sanitize(operator), TokenType.OP);
         }
+        for (String operator : manager.getAllTreeValueOperators()) {
+            lexer.unregister(Pattern.sanitize(operator), TokenType.TREE_VALUE_OP);
+        }
         for (String function : manager.getAllFunctions()) {
             lexer.unregister(Pattern.sanitize(function), TokenType.FUNCTION);
         }
+        for (String function : manager.getAllTreeValueFunctions()) {
+            lexer.unregister(Pattern.sanitize(function), TokenType.TREE_VALUE_FUNCTION);
+        }
     }
 
 }

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

@@ -1,6 +1,5 @@
 package org.nwapw.abacus.parsing;
 
-import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.function.OperatorAssociativity;
 import org.nwapw.abacus.function.OperatorType;
@@ -17,10 +16,6 @@ import java.util.*;
  */
 public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListener {
 
-    /**
-     * The Abacus instance used to create number instances.
-     */
-    private Abacus abacus;
     /**
      * Map of operator precedences, loaded from the plugin operators.
      */
@@ -35,12 +30,9 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
     private Map<String, OperatorType> typeMap;
 
     /**
-     * Creates a new Shunting Yard parser with the given Abacus instance.
-     *
-     * @param abacus the abacus instance.
+     * Creates a new Shunting Yard parser.
      */
-    public ShuntingYardParser(Abacus abacus) {
-        this.abacus = abacus;
+    public ShuntingYardParser() {
         precedenceMap = new HashMap<>();
         associativityMap = new HashMap<>();
         typeMap = new HashMap<>();
@@ -61,12 +53,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             Match<TokenType> match = from.remove(0);
             previousType = matchType;
             matchType = match.getType();
-            if (matchType == TokenType.NUM) {
+            if (matchType == TokenType.NUM || matchType == TokenType.VARIABLE) {
                 output.add(match);
-            } else if (matchType == TokenType.FUNCTION) {
+            } else if (matchType == TokenType.FUNCTION || matchType == TokenType.TREE_VALUE_FUNCTION) {
                 output.add(new Match<>("", TokenType.INTERNAL_FUNCTION_END));
                 tokenStack.push(match);
-            } else if (matchType == TokenType.OP) {
+            } else if (matchType == TokenType.OP || matchType == TokenType.TREE_VALUE_OP) {
                 String tokenString = match.getContent();
                 OperatorType type = typeMap.get(tokenString);
                 int precedence = precedenceMap.get(tokenString);
@@ -78,7 +70,7 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                 }
 
                 if (tokenString.equals("-") && (previousType == null || previousType == TokenType.OP ||
-                        previousType == TokenType.OPEN_PARENTH)) {
+                        previousType == TokenType.TREE_VALUE_OP || previousType == TokenType.OPEN_PARENTH)) {
                     from.add(0, new Match<>("`", TokenType.OP));
                     continue;
                 }
@@ -86,9 +78,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                 while (!tokenStack.empty() && type == OperatorType.BINARY_INFIX) {
                     Match<TokenType> otherMatch = tokenStack.peek();
                     TokenType otherMatchType = otherMatch.getType();
-                    if (!(otherMatchType == TokenType.OP || otherMatchType == TokenType.FUNCTION)) break;
+                    if (!(otherMatchType == TokenType.OP ||
+                            otherMatchType == TokenType.TREE_VALUE_OP ||
+                            otherMatchType == TokenType.FUNCTION ||
+                            otherMatchType == TokenType.TREE_VALUE_FUNCTION)) break;
 
-                    if (otherMatchType == TokenType.OP) {
+                    if (otherMatchType == TokenType.OP || otherMatchType == TokenType.TREE_VALUE_OP) {
                         int otherPrecedence = precedenceMap.get(otherMatch.getContent());
                         if (otherPrecedence < precedence ||
                                 (associativity == OperatorAssociativity.RIGHT && otherPrecedence == precedence)) {
@@ -113,7 +108,10 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
         while (!tokenStack.empty()) {
             Match<TokenType> match = tokenStack.peek();
             TokenType newMatchType = match.getType();
-            if (!(newMatchType == TokenType.OP || newMatchType == TokenType.FUNCTION)) return null;
+            if (!(newMatchType == TokenType.OP ||
+                    newMatchType == TokenType.TREE_VALUE_OP ||
+                    newMatchType == TokenType.FUNCTION ||
+                    newMatchType == TokenType.TREE_VALUE_FUNCTION)) return null;
             output.add(tokenStack.pop());
         }
         return output;
@@ -129,28 +127,43 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
         if (matches.size() == 0) return null;
         Match<TokenType> match = matches.remove(0);
         TokenType matchType = match.getType();
-        if (matchType == TokenType.OP) {
+        if (matchType == TokenType.OP || matchType == TokenType.TREE_VALUE_OP) {
             String operator = match.getContent();
             OperatorType type = typeMap.get(operator);
             if (type == OperatorType.BINARY_INFIX) {
                 TreeNode right = constructRecursive(matches);
                 TreeNode left = constructRecursive(matches);
                 if (left == null || right == null) return null;
-                else return new BinaryNode(operator, left, right);
+                if (matchType == TokenType.OP) {
+                    return new NumberBinaryNode(operator, left, right);
+                } else {
+                    return new TreeValueBinaryNode(operator, left, right);
+                }
             } else {
                 TreeNode applyTo = constructRecursive(matches);
                 if (applyTo == null) return null;
-                else return new UnaryNode(operator, applyTo);
+                if (matchType == TokenType.OP) {
+                    return new NumberUnaryNode(operator, applyTo);
+                } else {
+                    return new TreeValueUnaryNode(operator, applyTo);
+                }
             }
         } else if (matchType == TokenType.NUM) {
-            return new NumberNode(abacus.numberFromString(match.getContent()));
-        } else if (matchType == TokenType.FUNCTION) {
+            return new NumberNode(match.getContent());
+        } else if (matchType == TokenType.VARIABLE) {
+            return new VariableNode(match.getContent());
+        } else if (matchType == TokenType.FUNCTION || matchType == TokenType.TREE_VALUE_FUNCTION) {
             String functionName = match.getContent();
-            FunctionNode node = new FunctionNode(functionName);
+            CallNode node;
+            if (matchType == TokenType.FUNCTION) {
+                node = new FunctionNode(functionName);
+            } else {
+                node = new TreeValueFunctionNode(functionName);
+            }
             while (!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END) {
                 TreeNode argument = constructRecursive(matches);
                 if (argument == null) return null;
-                node.prependChild(argument);
+                node.getChildren().add(0, argument);
             }
             if (matches.isEmpty()) return null;
             matches.remove(0);
@@ -176,6 +189,12 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             associativityMap.put(operator, operatorInstance.getAssociativity());
             typeMap.put(operator, operatorInstance.getType());
         }
+        for (String operator : manager.getAllTreeValueOperators()) {
+            Operator operatorInstance = manager.treeValueOperatorFor(operator);
+            precedenceMap.put(operator, operatorInstance.getPrecedence());
+            associativityMap.put(operator, operatorInstance.getAssociativity());
+            typeMap.put(operator, operatorInstance.getType());
+        }
     }
 
     @Override

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

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

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

@@ -1,10 +1,8 @@
 package org.nwapw.abacus.plugin;
 
-import org.nwapw.abacus.function.Documentation;
-import org.nwapw.abacus.function.DocumentationType;
-import org.nwapw.abacus.function.Function;
-import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.*;
 import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.variables.VariableDatabase;
 
 /**
  * A plugin class that can be externally implemented and loaded via the
@@ -65,10 +63,21 @@ public abstract class Plugin {
      * @param name       the name to register by.
      * @param toRegister the function implementation.
      */
-    protected final void registerFunction(String name, Function toRegister) {
+    protected final void registerFunction(String name, NumberFunction toRegister) {
         manager.registerFunction(name, toRegister);
     }
 
+    /**
+     * To be used in load(). Registers a tree value function abstract class
+     * with the plugin internally, which makes it accessible to the plugin manager.
+     *
+     * @param name       the name to register by.
+     * @param toRegister the tree value function implementation.
+     */
+    protected final void registerTreeValueFunction(String name, TreeValueFunction toRegister) {
+        manager.registerTreeValueFunction(name, toRegister);
+    }
+
     /**
      * To be used in load(). Registers an operator abstract class
      * with the plugin internally, which makes it accessible to
@@ -77,10 +86,22 @@ public abstract class Plugin {
      * @param name     the name of the operator.
      * @param operator the operator to register.
      */
-    protected final void registerOperator(String name, Operator operator) {
+    protected final void registerOperator(String name, NumberOperator operator) {
         manager.registerOperator(name, operator);
     }
 
+    /**
+     * To be used in load(). Registers an operator
+     * with the plugin internally, which makes it accessible
+     * to the plugin manager.
+     *
+     * @param name     the name of the tree value operator.
+     * @param operator the tree value operator to register.
+     */
+    protected final void registerTreeValueOperator(String name, TreeValueOperator operator) {
+        manager.registerTreeValueOperator(name, operator);
+    }
+
     /**
      * To be used in load(). Registers a new number implementation with the plugin.
      * This makes it accessible to the plugin manager.
@@ -110,10 +131,22 @@ public abstract class Plugin {
      * @param name the name for which to search
      * @return the resulting function, or null if none was found for that name.
      */
-    protected final Function functionFor(String name) {
+    protected final NumberFunction functionFor(String name) {
         return manager.functionFor(name);
     }
 
+    /**
+     * Searches the PluginManager for the given function name.
+     * This can be used by the plugins internally in order to call functions
+     * they do not provide.
+     *
+     * @param name the name for which to search.
+     * @return the resulting tree value function, or null if none was found for that name.
+     */
+    protected final TreeValueFunction treeValueFunctionFor(String name) {
+        return manager.treeValueFunctionFor(name);
+    }
+
     /**
      * Searches the PluginManager for the given operator name.
      * This can be used by the plugins internally in order to call
@@ -122,10 +155,22 @@ public abstract class Plugin {
      * @param name the name for which to search
      * @return the resulting operator, or null if none was found for that name.
      */
-    protected final Operator operatorFor(String name) {
+    protected final NumberOperator operatorFor(String name) {
         return manager.operatorFor(name);
     }
 
+    /**
+     * Searches the PluginManager for the given tree value operator name.
+     * This can be used by the plugins internally in order to call
+     * operations they do not provide.
+     *
+     * @param name the name for which to search.
+     * @return the resulting tree value operator, or null if none was found for that name.
+     */
+    protected final TreeValueOperator treeValueOperatorFor(String name) {
+        return manager.treeValueOperatorFor(name);
+    }
+
     /**
      * Searches the PluginManager for the given number implementation
      * name. This can be used by the plugins internally in order to find
@@ -175,4 +220,12 @@ public abstract class Plugin {
      */
     public abstract void onDisable();
 
+    /**
+     * Get the variable database.
+     * @return the variable database.
+     */
+    public final VariableDatabase getVariableDatabase(){
+        return manager.getVariableDatabase();
+    }
+
 }

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

@@ -1,11 +1,9 @@
 package org.nwapw.abacus.plugin;
 
 import org.nwapw.abacus.Abacus;
-import org.nwapw.abacus.function.Documentation;
-import org.nwapw.abacus.function.DocumentationType;
-import org.nwapw.abacus.function.Function;
-import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.*;
 import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.variables.VariableDatabase;
 
 import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
@@ -30,11 +28,19 @@ public class PluginManager {
     /**
      * The map of functions registered by the plugins.
      */
-    private Map<String, Function> registeredFunctions;
+    private Map<String, NumberFunction> registeredFunctions;
+    /**
+     * The map of tree value functions regstered by the plugins.
+     */
+    private Map<String, TreeValueFunction> registeredTreeValueFunctions;
     /**
      * The map of operators registered by the plugins
      */
-    private Map<String, Operator> registeredOperators;
+    private Map<String, NumberOperator> registeredOperators;
+    /**
+     * The map of tree value operators registered by the plugins.
+     */
+    private Map<String, TreeValueOperator> registeredTreeValueOperators;
     /**
      * The map of number implementations registered by the plugins.
      */
@@ -44,10 +50,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.
      */
@@ -72,10 +81,13 @@ public class PluginManager {
         loadedPluginClasses = new HashSet<>();
         plugins = new HashSet<>();
         registeredFunctions = new HashMap<>();
+        registeredTreeValueFunctions = new HashMap<>();
         registeredOperators = new HashMap<>();
+        registeredTreeValueOperators = new HashMap<>();
         registeredNumberImplementations = new HashMap<>();
         registeredDocumentation = new HashSet<>();
-        cachedInterfaceImplementations = new HashMap<>();
+        interfaceImplementations = new HashMap<>();
+        interfaceImplementationNames = new HashMap<>();
         cachedPi = new HashMap<>();
         listeners = new HashSet<>();
     }
@@ -86,20 +98,40 @@ public class PluginManager {
      * @param name     the name of the function.
      * @param function the function to register.
      */
-    public void registerFunction(String name, Function function) {
+    public void registerFunction(String name, NumberFunction function) {
         registeredFunctions.put(name, function);
     }
 
+    /**
+     * Registers a tree value function under the given name.
+     *
+     * @param name     the name of the function.
+     * @param function the function to register.
+     */
+    public void registerTreeValueFunction(String name, TreeValueFunction function) {
+        registeredTreeValueFunctions.put(name, function);
+    }
+
     /**
      * Registers an operator under the given name.
      *
      * @param name     the name of the operator.
      * @param operator the operator to register.
      */
-    public void registerOperator(String name, Operator operator) {
+    public void registerOperator(String name, NumberOperator operator) {
         registeredOperators.put(name, operator);
     }
 
+    /**
+     * Registers a tree value operator under the given name.
+     *
+     * @param name     the name of the tree value operator.
+     * @param operator the tree value operator to register.
+     */
+    public void registerTreeValueOperator(String name, TreeValueOperator operator) {
+        registeredTreeValueOperators.put(name, operator);
+    }
+
     /**
      * Registers a number implementation under the given name.
      *
@@ -108,6 +140,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);
     }
 
     /**
@@ -126,20 +160,40 @@ public class PluginManager {
      * @param name the name of the function.
      * @return the function, or null if it was not found.
      */
-    public Function functionFor(String name) {
+    public NumberFunction functionFor(String name) {
         return registeredFunctions.get(name);
     }
 
+    /**
+     * Gets the tree value function registered under the given name.
+     *
+     * @param name the name of the function.
+     * @return the function, or null if it was not found.
+     */
+    public TreeValueFunction treeValueFunctionFor(String name) {
+        return registeredTreeValueFunctions.get(name);
+    }
+
     /**
      * Gets the operator registered under the given name.
      *
      * @param name the name of the operator.
      * @return the operator, or null if it was not found.
      */
-    public Operator operatorFor(String name) {
+    public NumberOperator operatorFor(String name) {
         return registeredOperators.get(name);
     }
 
+    /**
+     * Gets the tree value operator registered under the given name.
+     *
+     * @param name the name of the tree value operator.
+     * @return the operator, or null if it was not found.
+     */
+    public TreeValueOperator treeValueOperatorFor(String name) {
+        return registeredTreeValueOperators.get(name);
+    }
+
     /**
      * Gets the number implementation registered under the given name.
      *
@@ -179,17 +233,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);
     }
 
     /**
@@ -277,10 +331,13 @@ public class PluginManager {
             plugin.disable();
         }
         registeredFunctions.clear();
+        registeredTreeValueFunctions.clear();
         registeredOperators.clear();
+        registeredTreeValueOperators.clear();
         registeredNumberImplementations.clear();
         registeredDocumentation.clear();
-        cachedInterfaceImplementations.clear();
+        interfaceImplementationNames.clear();
+        interfaceImplementations.clear();
         cachedPi.clear();
         listeners.forEach(e -> e.onUnload(this));
     }
@@ -302,6 +359,15 @@ public class PluginManager {
         return registeredFunctions.keySet();
     }
 
+    /**
+     * Gets all the tree vlaue functions loaded by the PluginManager.
+     *
+     * @return the set of all the tree value functions that were loaded.
+     */
+    public Set<String> getAllTreeValueFunctions() {
+        return registeredTreeValueFunctions.keySet();
+    }
+
     /**
      * Gets all the operators loaded by the Plugin Manager.
      *
@@ -311,6 +377,15 @@ public class PluginManager {
         return registeredOperators.keySet();
     }
 
+    /**
+     * Gets all the tree value operators loaded by the PluginManager.
+     *
+     * @return the set of all tree value operators that were loaded.
+     */
+    public Set<String> getAllTreeValueOperators() {
+        return registeredTreeValueOperators.keySet();
+    }
+
     /**
      * Gets all the number implementations loaded by the Plugin Manager.
      *
@@ -347,4 +422,12 @@ public class PluginManager {
     public Set<Class<?>> getLoadedPluginClasses() {
         return loadedPluginClasses;
     }
+
+    /**
+     * Gets the variable database.
+     * @return the database.
+     */
+    public VariableDatabase getVariableDatabase(){
+        return abacus.getVariableDatabase();
+    }
 }

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

@@ -1,13 +1,17 @@
 package org.nwapw.abacus.plugin;
 
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.nwapw.abacus.function.*;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.number.PreciseNumber;
+import org.nwapw.abacus.tree.Reducer;
+import org.nwapw.abacus.tree.TreeNode;
+import org.nwapw.abacus.tree.VariableNode;
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.function.BiFunction;
 
 /**
  * The plugin providing standard functions such as addition and subtraction to
@@ -16,85 +20,96 @@ import java.util.function.BiFunction;
 public class StandardPlugin extends Plugin {
 
     /**
-     * The addition operator, +
+     * The set operator.
      */
-    public static final Operator OP_ADD = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
+    public final TreeValueOperator opSet = new TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length >= 1;
+        public boolean matchesParams(NumberImplementation implementation, TreeNode[] params) {
+            return params.length == 2 && params[0] instanceof VariableNode;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            NumberInterface sum = params[0];
-            for (int i = 1; i < params.length; i++) {
-                sum = sum.add(params[i]);
-            }
-            return sum;
+        public NumberInterface applyWithReducerInternal(NumberImplementation implementation, Reducer<? extends NumberInterface> reducer, TreeNode[] params) {
+            String assignTo = ((VariableNode) params[0]).getVariable();
+            NumberInterface value = params[1].reduce(reducer);
+            getVariableDatabase().getVariables().put(assignTo, value);
+            return value;
         }
-    });
+    };
     /**
-     * The subtraction operator, -
+     * The define operator.
      */
-    public static final Operator OP_SUBTRACT = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
+    public final TreeValueOperator opDefine = new TreeValueOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, TreeNode[] params) {
+            return params.length == 2 && params[0] instanceof VariableNode;
+        }
+
+        @Nullable
+        @Override
+        public NumberInterface applyWithReducerInternal(NumberImplementation implementation, Reducer<? extends NumberInterface> reducer, TreeNode[] params) {
+            String assignTo = ((VariableNode) params[0]).getVariable();
+            getVariableDatabase().getDefinitions().put(assignTo, params[1]);
+            return params[1].reduce(reducer);
+        }
+    };
+    /**
+     * The addition operator, +
+     */
+    public static final NumberOperator OP_ADD = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
+        @Override
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return params[0].add(params[1]);
+        }
+    };
+    /**
+     * The subtraction operator, -
+     */
+    public static final NumberOperator OP_SUBTRACT = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
+        @Override
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+            return params.length == 2;
+        }
+
+        @Override
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             return params[0].subtract(params[1]);
 
         }
-    });
+    };
     /**
      * The negation operator, -
      */
-    public static final Operator OP_NEGATE = new Operator(OperatorAssociativity.LEFT, OperatorType.UNARY_PREFIX, 0, new Function() {
+    public static final NumberOperator OP_NEGATE = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.UNARY_PREFIX, 0) {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             return params[0].negate();
         }
-    });
+    };
     /**
      * The multiplication operator, *
      */
-    public static final Operator OP_MULTIPLY = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1, new Function() {
+    public static final NumberOperator OP_MULTIPLY = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1) {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length >= 1;
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+            return params.length == 2;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            NumberInterface product = params[0];
-            for (int i = 1; i < params.length; i++) {
-                product = product.multiply(params[i]);
-            }
-            return product;
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return params[0].multiply(params[1]);
         }
-    });
-    /**
-     * The combination operator.
-     */
-    public static final Operator OP_NCR = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0, new Function() {
-        @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 2 && params[0].fractionalPart().signum() == 0
-                    && params[1].fractionalPart().signum() == 0;
-        }
-
-        @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return OP_NPR.getFunction().apply(params).divide(OP_FACTORIAL.getFunction().apply(params[1]));
-        }
-    });
+    };
     /**
      * The implementation for double-based naive numbers.
      */
@@ -120,7 +135,7 @@ public class StandardPlugin extends Plugin {
 
         @Override
         public NumberInterface instanceForPi() {
-            NumberInterface C = FUNCTION_SQRT.apply(new PreciseNumber("10005")).multiply(new PreciseNumber("426880"));
+            NumberInterface C = FUNCTION_SQRT.apply(this, new PreciseNumber("10005")).multiply(new PreciseNumber("426880"));
             NumberInterface M = PreciseNumber.ONE;
             NumberInterface L = new PreciseNumber("13591409");
             NumberInterface X = M;
@@ -145,42 +160,38 @@ 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 Operator OP_DIVIDE = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1, new Function() {
+    public static final NumberOperator OP_DIVIDE = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1) {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 2 && params[1].compareTo(fromInt(params[0].getClass(), 0)) != 0;
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+            return params.length == 2 && params[1].compareTo(implementation.instanceForString(Integer.toString(0))) != 0;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             return params[0].divide(params[1]);
         }
-    });
+    };
     /**
      * The factorial operator, !
      */
-    public static final Operator OP_FACTORIAL = new Operator(OperatorAssociativity.RIGHT, OperatorType.UNARY_POSTFIX, 0, new Function() {
+    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
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1
-                    && params[0].fractionalPart().compareTo(fromInt(params[0].getClass(), 0)) == 0
+                    && params[0].fractionalPart().compareTo(implementation.instanceForString("0")) == 0
                     && params[0].signum() >= 0;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             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.
@@ -194,75 +205,90 @@ public class StandardPlugin extends Plugin {
                     storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
                 }*/
         }
-    });
+    };
     /**
      * The permutation operator.
      */
-    public static final Operator OP_NPR = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0, new Function() {
+    public static final NumberOperator OP_NPR = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 2 && params[0].fractionalPart().signum() == 0
                     && params[1].fractionalPart().signum() == 0;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             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;
         }
-    });
+    };
+    /**
+     * The combination operator.
+     */
+    public static final NumberOperator OP_NCR = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 0) {
+        @Override
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+            return params.length == 2 && params[0].fractionalPart().signum() == 0
+                    && params[1].fractionalPart().signum() == 0;
+        }
+
+        @Override
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return OP_NPR.apply(implementation, params).divide(OP_FACTORIAL.apply(implementation, params[1]));
+        }
+    };
     /**
      * The absolute value function, abs(-3) = 3
      */
-    public static final Function FUNCTION_ABS = new Function() {
+    public static final NumberFunction FUNCTION_ABS = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return params[0].multiply(fromInt(params[0].getClass(), params[0].signum()));
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return params[0].multiply(implementation.instanceForString(Integer.toString(params[0].signum())));
         }
     };
     /**
      * The natural log function.
      */
-    public static final Function FUNCTION_LN = new Function() {
+    public static final NumberFunction FUNCTION_LN = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1 && params[0].compareTo(fromInt(params[0].getClass(), 0)) > 0;
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+            return params.length == 1 && params[0].compareTo(implementation.instanceForString("0")) > 0;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             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(implementation, 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;
@@ -270,7 +296,7 @@ public class StandardPlugin extends Plugin {
                     }
                 }
             }
-            return getLog2(param).multiply(fromInt(param.getClass(), powersOf2)).add(getLogPartialSum(param));
+            return getLog2(implementation, param).multiply(implementation.instanceForString(Integer.toString(powersOf2))).add(getLogPartialSum(implementation, param));
         }
 
         /**
@@ -279,16 +305,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(NumberImplementation implementation, NumberInterface x) {
 
             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(implementation, 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;
@@ -299,21 +325,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;
@@ -322,24 +348,24 @@ public class StandardPlugin extends Plugin {
     /**
      * Gets a random number smaller or equal to the given number's integer value.
      */
-    public static final Function FUNCTION_RAND_INT = new Function() {
+    public static final NumberFunction FUNCTION_RAND_INT = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return fromInt(params[0].getClass(), (int) Math.round(Math.random() * params[0].floor().intValue()));
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return implementation.instanceForString(Long.toString(Math.round(Math.random() * params[0].floor().intValue())));
         }
     };
     /**
      * The caret / pow operator, ^
      */
-    public static final Operator OP_CARET = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2, new Function() {
+    public static final NumberOperator OP_CARET = new NumberOperator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2) {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            NumberInterface zero = fromInt(params[0].getClass(), 0);
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+            NumberInterface zero = implementation.instanceForString("0");
             return params.length == 2
                     && !(params[0].compareTo(zero) == 0
                     && params[1].compareTo(zero) == 0)
@@ -347,65 +373,65 @@ public class StandardPlugin extends Plugin {
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            NumberInterface zero = fromInt(params[0].getClass(), 0);
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            NumberInterface zero = implementation.instanceForString("0");
             if (params[0].compareTo(zero) == 0)
                 return zero;
             else if (params[1].compareTo(zero) == 0)
-                return fromInt(params[0].getClass(), 1);
+                return implementation.instanceForString("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) {
+            if (params[0].fractionalPart().compareTo(implementation.instanceForString("0")) == 0
+                    && FUNCTION_ABS.apply(implementation, params[1]).compareTo(implementation.instanceForString(Integer.toString(Integer.MAX_VALUE))) < 0
+                    && FUNCTION_ABS.apply(implementation, params[1]).compareTo(implementation.instanceForString("1")) >= 0) {
                 NumberInterface[] newParams = {params[0], params[1].fractionalPart()};
-                return params[0].intPow(params[1].floor().intValue()).multiply(applyInternal(newParams));
+                return params[0].intPow(params[1].floor().intValue()).multiply(applyInternal(implementation, newParams));
             }
-            return FUNCTION_EXP.apply(FUNCTION_LN.apply(FUNCTION_ABS.apply(params[0])).multiply(params[1]));
+            return FUNCTION_EXP.apply(implementation, FUNCTION_LN.apply(implementation, FUNCTION_ABS.apply(implementation, params[0])).multiply(params[1]));
         }
-    });
+    };
     /**
      * The square root function.
      */
-    public static final Function FUNCTION_SQRT = new Function() {
+    public static final NumberFunction FUNCTION_SQRT = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return OP_CARET.getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return OP_CARET.apply(implementation, params[0], implementation.instanceForString(".5"));
         }
     };
-    private static final HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> FACTORIAL_LISTS = new HashMap<>();
+    private static final HashMap<NumberImplementation, ArrayList<NumberInterface>> FACTORIAL_LISTS = new HashMap<>();
     /**
      * The exponential function, exp(1) = e^1 = 2.71...
      */
-    public static final Function FUNCTION_EXP = new Function() {
+    public static final NumberFunction FUNCTION_EXP = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             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(implementation, 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);
                 }
@@ -418,126 +444,126 @@ public class StandardPlugin extends Plugin {
     /**
      * The sine function (the argument is interpreted in radians).
      */
-    public final Function functionSin = new Function() {
+    public final NumberFunction functionSin = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             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(implementation, 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(implementation, theta);
         }
     };
     /**
      * The cosine function (the argument is in radians).
      */
-    public final Function functionCos = new Function() {
+    public final NumberFunction functionCos = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return functionSin.apply(piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return functionSin.apply(implementation, piFor(params[0].getClass()).divide(implementation.instanceForString("2"))
                     .subtract(params[0]));
         }
     };
     /**
      * The tangent function (the argument is in radians).
      */
-    public final Function functionTan = new Function() {
+    public final NumberFunction functionTan = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return functionSin.apply(params[0]).divide(functionCos.apply(params[0]));
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return functionSin.apply(implementation, params[0]).divide(functionCos.apply(implementation, params[0]));
         }
     };
     /**
      * The secant function (the argument is in radians).
      */
-    public final Function functionSec = new Function() {
+    public final NumberFunction functionSec = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return fromInt(params[0].getClass(), 1).divide(functionCos.apply(params[0]));
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return implementation.instanceForString("1").divide(functionCos.apply(implementation, params[0]));
         }
     };
     /**
      * The cosecant function (the argument is in radians).
      */
-    public final Function functionCsc = new Function() {
+    public final NumberFunction functionCsc = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return fromInt(params[0].getClass(), 1).divide(functionSin.apply(params[0]));
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return implementation.instanceForString("1").divide(functionSin.apply(implementation, params[0]));
         }
     };
     /**
      * The cotangent function (the argument is in radians).
      */
-    public final Function functionCot = new Function() {
+    public final NumberFunction functionCot = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return functionCos.apply(params[0]).divide(functionSin.apply(params[0]));
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return functionCos.apply(implementation, params[0]).divide(functionSin.apply(implementation, params[0]));
         }
     };
 
     /**
      * The arcsine function (return type in radians).
      */
-    public final Function functionArcsin = new Function() {
+    public final NumberFunction functionArcsin = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1
-                    && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 1)) <= 0;
+                    && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) <= 0;
         }
 
         @Override
-        protected 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(NumberImplementation implementation, NumberInterface[] params) {
+            if (FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString(".8")) >= 0) {
+                NumberInterface[] newParams = {FUNCTION_SQRT.apply(implementation, implementation.instanceForString("1").subtract(params[0].multiply(params[0])))};
+                return piFor(params[0].getClass()).divide(implementation.instanceForString("2"))
+                        .subtract(applyInternal(implementation, 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(implementation, 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;
@@ -547,86 +573,86 @@ public class StandardPlugin extends Plugin {
     /**
      * The arccosine function.
      */
-    public final Function functionArccos = new Function() {
+    public final NumberFunction functionArccos = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1 && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 1)) <= 0;
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+            return params.length == 1 && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) <= 0;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
-                    .subtract(functionArcsin.apply(params));
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return piFor(params[0].getClass()).divide(implementation.instanceForString("2"))
+                    .subtract(functionArcsin.apply(implementation, params));
         }
     };
 
     /**
      * The arccosecant function.
      */
-    public final Function functionArccsc = new Function() {
+    public final NumberFunction functionArccsc = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1 && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 1)) >= 0;
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+            return params.length == 1 && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) >= 0;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            NumberInterface[] reciprocalParamArr = {fromInt(params[0].getClass(), 1).divide(params[0])};
-            return functionArcsin.apply(reciprocalParamArr);
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            NumberInterface[] reciprocalParamArr = {implementation.instanceForString("1").divide(params[0])};
+            return functionArcsin.apply(implementation, reciprocalParamArr);
         }
     };
 
     /**
      * The arcsecant function.
      */
-    public final Function functionArcsec = new Function() {
+    public final NumberFunction functionArcsec = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 1 && FUNCTION_ABS.apply(params[0]).compareTo(fromInt(params[0].getClass(), 1)) >= 0;
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+            return params.length == 1 && FUNCTION_ABS.apply(implementation, params[0]).compareTo(implementation.instanceForString("1")) >= 0;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            NumberInterface[] reciprocalParamArr = {fromInt(params[0].getClass(), 1).divide(params[0])};
-            return functionArccos.apply(reciprocalParamArr);
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            NumberInterface[] reciprocalParamArr = {implementation.instanceForString("1").divide(params[0])};
+            return functionArccos.apply(implementation, reciprocalParamArr);
         }
     };
 
     /**
      * The arctangent function.
      */
-    public final Function functionArctan = new Function() {
+    public final NumberFunction functionArctan = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             if (params[0].signum() == -1) {
                 NumberInterface[] negatedParams = {params[0].negate()};
-                return applyInternal(negatedParams).negate();
+                return applyInternal(implementation, 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(implementation, 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(implementation, 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(implementation, 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;
@@ -636,16 +662,16 @@ public class StandardPlugin extends Plugin {
     /**
      * The arccotangent function. Range: (0, pi).
      */
-    public final Function functionArccot = new Function() {
+    public final NumberFunction functionArccot = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 1;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return piFor(params[0].getClass()).divide(fromInt(params[0].getClass(), 2))
-                    .subtract(functionArctan.apply(params));
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+            return piFor(params[0].getClass()).divide(implementation.instanceForString("2"))
+                    .subtract(functionArctan.apply(implementation, params));
         }
     };
 
@@ -653,40 +679,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);
@@ -698,16 +709,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(NumberImplementation implementation, 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(implementation, n));
             sum = sum.add(currentTerm);
-        } while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0);
+        } while (FUNCTION_ABS.apply(implementation, currentTerm).compareTo(maxError) > 0);
         return sum;
     }
 
@@ -717,33 +728,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(NumberImplementation implementation, NumberInterface phi, NumberInterface pi) {
+        NumberInterface twoPi = pi.multiply(implementation.instanceForString("2"));
+        NumberInterface theta = FUNCTION_ABS.apply(implementation, phi).subtract(twoPi
+                .multiply(FUNCTION_ABS.apply(implementation, phi).divide(twoPi).floor())); //Now theta is in [0, 2pi).
         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);
@@ -757,6 +751,9 @@ public class StandardPlugin extends Plugin {
         registerOperator("^", OP_CARET);
         registerOperator("!", OP_FACTORIAL);
 
+        registerTreeValueOperator("=", opSet);
+        registerTreeValueOperator(":=", opDefine);
+
         registerOperator("nPr", OP_NPR);
         registerOperator("nCr", OP_NCR);
 
@@ -832,6 +829,6 @@ public class StandardPlugin extends Plugin {
 
     @Override
     public void onDisable() {
-
+        FACTORIAL_LISTS.clear();
     }
 }

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

@@ -1,8 +1,14 @@
 package org.nwapw.abacus.tree;
 
 import org.nwapw.abacus.Abacus;
-import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.NumberFunction;
+import org.nwapw.abacus.function.NumberOperator;
+import org.nwapw.abacus.function.TreeValueFunction;
+import org.nwapw.abacus.function.TreeValueOperator;
 import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.number.PromotionManager;
+import org.nwapw.abacus.number.PromotionResult;
+import org.nwapw.abacus.variables.VariableDatabase;
 
 /**
  * A reducer implementation that turns a tree into a single number.
@@ -26,27 +32,60 @@ public class NumberReducer implements Reducer<NumberInterface> {
 
     @Override
     public NumberInterface reduceNode(TreeNode node, Object... children) {
+        PromotionManager manager = abacus.getPromotionManager();
         if (node instanceof NumberNode) {
-            return ((NumberNode) node).getNumber();
-        } else if (node instanceof BinaryNode) {
+            return abacus.getNumberImplementation().instanceForString(((NumberNode) node).getNumber());
+        } else if (node instanceof VariableNode) {
+            VariableDatabase database = abacus.getVariableDatabase();
+            String name = ((VariableNode) node).getVariable();
+            NumberInterface variable = database.getVariables().get(name);
+            if(variable != null) return variable;
+            TreeNode definition = database.getDefinitions().get(name);
+            if(definition != null) return definition.reduce(this);
+            return abacus.getNumberImplementation().instanceForString("0");
+        } else if (node instanceof NumberBinaryNode) {
             NumberInterface left = (NumberInterface) children[0];
             NumberInterface right = (NumberInterface) children[1];
-            Function function = abacus.getPluginManager().operatorFor(((BinaryNode) node).getOperation()).getFunction();
-            if (function == null) return null;
-            return function.apply(left, right);
-        } else if (node instanceof UnaryNode) {
+            NumberOperator operator = abacus.getPluginManager().operatorFor(((BinaryNode) node).getOperation());
+            PromotionResult result = manager.promote(left, right);
+            if (result == null) return null;
+            return operator.apply(result.getPromotedTo(), result.getItems());
+        } else if (node instanceof NumberUnaryNode) {
             NumberInterface child = (NumberInterface) children[0];
-            Function functionn = abacus.getPluginManager().operatorFor(((UnaryNode) node).getOperation()).getFunction();
-            if (functionn == null) return null;
-            return functionn.apply(child);
+            NumberOperator operator = abacus.getPluginManager().operatorFor(((UnaryNode) node).getOperation());
+            return operator.apply(abacus.getPluginManager().interfaceImplementationFor(child.getClass()), child);
         } else if (node instanceof FunctionNode) {
             NumberInterface[] convertedChildren = new NumberInterface[children.length];
             for (int i = 0; i < convertedChildren.length; i++) {
                 convertedChildren[i] = (NumberInterface) children[i];
             }
-            Function function = abacus.getPluginManager().functionFor(((FunctionNode) node).getFunction());
+            NumberFunction function = abacus.getPluginManager().functionFor(((FunctionNode) node).getCallTo());
             if (function == null) return null;
-            return function.apply(convertedChildren);
+            PromotionResult result = manager.promote(convertedChildren);
+            if (result == null) return null;
+            return function.apply(result.getPromotedTo(), result.getItems());
+        } else if (node instanceof TreeValueFunctionNode) {
+            CallNode callNode = (CallNode) node;
+            TreeNode[] realChildren = new TreeNode[callNode.getChildren().size()];
+            for (int i = 0; i < realChildren.length; i++) {
+                realChildren[i] = callNode.getChildren().get(i);
+            }
+            TreeValueFunction function =
+                    abacus.getPluginManager().treeValueFunctionFor(callNode.getCallTo());
+            if (function == null) return null;
+            return function.applyWithReducer(abacus.getNumberImplementation(), this, realChildren);
+        } else if (node instanceof TreeValueBinaryNode) {
+            BinaryNode binaryNode = (BinaryNode) node;
+            TreeValueOperator operator = abacus.getPluginManager()
+                    .treeValueOperatorFor(binaryNode.getOperation());
+            if (operator == null) return null;
+            return operator.applyWithReducer(abacus.getNumberImplementation(), this, binaryNode.getLeft(), binaryNode.getRight());
+        } else if (node instanceof TreeValueUnaryNode) {
+            UnaryNode unaryNode = (UnaryNode) node;
+            TreeValueOperator operator = abacus.getPluginManager()
+                    .treeValueOperatorFor(unaryNode.getOperation());
+            if (operator == null) return null;
+            return operator.applyWithReducer(abacus.getNumberImplementation(), this, unaryNode.getApplyTo());
         }
         return null;
     }

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

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

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

@@ -0,0 +1,90 @@
+package org.nwapw.abacus
+
+import org.nwapw.abacus.config.Configuration
+import org.nwapw.abacus.number.NumberInterface
+import org.nwapw.abacus.number.PromotionManager
+import org.nwapw.abacus.parsing.LexerTokenizer
+import org.nwapw.abacus.parsing.ShuntingYardParser
+import org.nwapw.abacus.parsing.TreeBuilder
+import org.nwapw.abacus.plugin.NumberImplementation
+import org.nwapw.abacus.plugin.PluginManager
+import org.nwapw.abacus.plugin.StandardPlugin
+import org.nwapw.abacus.tree.NumberReducer
+import org.nwapw.abacus.tree.TreeNode
+import org.nwapw.abacus.variables.VariableDatabase
+
+/**
+ * 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 reducer used to turn trees into a single number.
+     */
+    val numberReducer = NumberReducer(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 database of variable definitions.
+     */
+    val variableDatabase = VariableDatabase(this)
+    /**
+     * The number implementation used by default.
+     */
+    val numberImplementation: NumberImplementation
+        get() {
+            val selectedImplementation =
+                    pluginManager.numberImplementationFor(configuration.numberImplementation)
+            if (selectedImplementation != null) return selectedImplementation
+            return StandardPlugin.IMPLEMENTATION_NAIVE
+        }
+
+    init {
+        pluginManager.addListener(tokenizer)
+        pluginManager.addListener(parser)
+        pluginManager.addListener(promotionManager)
+        pluginManager.addListener(variableDatabase)
+    }
+
+    /**
+     * 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 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.
+     */
+    fun evaluateTree(tree: TreeNode): NumberInterface? = tree.reduce(numberReducer)
+
+}

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/function/NumberFunction.kt

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

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

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

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

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

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

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

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

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

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

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

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

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

core/src/main/kotlin/org/nwapw/abacus/number/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,13 +11,7 @@ package org.nwapw.abacus.tree
  * @param left the left node.
  * @param right the right node.
  */
-data class BinaryNode(val operation: String, val left: TreeNode? = null, val right: TreeNode?) : TreeNode() {
-
-    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
-        val leftReduce = left?.reduce(reducer) ?: return null
-        val rightReduce = right?.reduce(reducer) ?: return null
-        return reducer.reduceNode(this, leftReduce, rightReduce)
-    }
+abstract class BinaryNode(val operation: String, val left: TreeNode? = null, val right: TreeNode?) : TreeNode() {
 
     override fun toString(): String {
         return "(" + (left?.toString() ?: "null") + operation + (right?.toString() ?: "null") + ")"

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

@@ -0,0 +1,29 @@
+package org.nwapw.abacus.tree
+
+/**
+ * Represents a more generic function call.
+ *
+ * This class does not specify how it should be reduced, allowing other classes
+ * to extend this functionality.
+ *
+ * @param callTo the name of the things being called.
+ */
+abstract class CallNode(val callTo: String) : TreeNode() {
+
+    /**
+     * The list of children this node has.
+     */
+    val children: MutableList<TreeNode> = mutableListOf()
+
+    override fun toString(): String {
+        val buffer = StringBuffer()
+        buffer.append(callTo)
+        buffer.append("(")
+        for (i in 0 until children.size) {
+            buffer.append(children[i].toString())
+            buffer.append(if (i != children.size - 1) ", " else ")")
+        }
+        return buffer.toString()
+    }
+
+}

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

@@ -8,45 +8,11 @@ package org.nwapw.abacus.tree
  *
  * @param function the function string.
  */
-data class FunctionNode(val function: String) : TreeNode() {
-
-    /**
-     * List of function parameters added to this node.
-     */
-    val children: MutableList<TreeNode> = mutableListOf()
+class FunctionNode(function: String) : CallNode(function) {
 
     override fun <T : Any> reduce(reducer: Reducer<T>): T? {
         val children = Array<Any>(children.size, { children[it].reduce(reducer) ?: return null; })
         return reducer.reduceNode(this, *children)
     }
 
-    override fun toString(): String {
-        val buffer = StringBuffer()
-        buffer.append(function)
-        buffer.append('(')
-        for (i in 0 until children.size) {
-            buffer.append(children[i].toString())
-            buffer.append(if (i == children.size - 1) ")" else ",")
-        }
-        return buffer.toString()
-    }
-
-    /**
-     * Appends a child to this node's list of children.
-     *
-     * @node the node to append.
-     */
-    fun appendChild(node: TreeNode) {
-        children.add(node)
-    }
-
-    /**
-     * Prepends a child to this node's list of children.
-     *
-     * @node the node to prepend.
-     */
-    fun prependChild(node: TreeNode) {
-        children.add(0, node)
-    }
-
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -9,12 +9,7 @@ package org.nwapw.abacus.tree
  * @param operation the operation applied to the given node.
  * @param applyTo the node to which the operation will be applied.
  */
-data class UnaryNode(val operation: String, val applyTo: TreeNode? = null) : TreeNode() {
-
-    override fun <T : Any> reduce(reducer: Reducer<T>): T? {
-        val reducedChild = applyTo?.reduce(reducer) ?: return null
-        return reducer.reduceNode(this, reducedChild)
-    }
+abstract class UnaryNode(val operation: String, val applyTo: TreeNode? = null) : TreeNode() {
 
     override fun toString(): String {
         return "(" + (applyTo?.toString() ?: "null") + ")" + operation

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

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

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

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

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

@@ -5,13 +5,14 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.config.Configuration;
+import org.nwapw.abacus.function.DomainException;
 import org.nwapw.abacus.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() {
@@ -28,11 +29,14 @@ public class CalculationTests {
         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)`^0.9999)");
+        testDomainException("0^0", "(0^0)");
+        testDomainException("(-13)^.9999", "((13)`^.9999)");
     }
 
 }

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

@@ -5,13 +5,11 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.config.Configuration;
-import org.nwapw.abacus.function.Function;
-import org.nwapw.abacus.function.Operator;
-import org.nwapw.abacus.function.OperatorAssociativity;
-import org.nwapw.abacus.function.OperatorType;
+import org.nwapw.abacus.function.*;
 import org.nwapw.abacus.lexing.pattern.Match;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.parsing.LexerTokenizer;
+import org.nwapw.abacus.plugin.NumberImplementation;
 import org.nwapw.abacus.plugin.Plugin;
 import org.nwapw.abacus.tree.TokenType;
 
@@ -19,26 +17,48 @@ import java.util.List;
 
 public class TokenizerTests {
 
-    private static Abacus abacus = new Abacus(new Configuration(0, "precise", new String[]{}));
+    private static Abacus abacus = new Abacus(new Configuration("precise", new String[]{}));
     private static LexerTokenizer lexerTokenizer = new LexerTokenizer();
-    private static Function subtractFunction = new Function() {
+    private static NumberFunction subtractFunction = new NumberFunction() {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
+        public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
             return params.length == 2;
         }
 
         @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
+        public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
             return params[0].subtract(params[1]);
         }
     };
     private static Plugin testPlugin = new Plugin(abacus.getPluginManager()) {
         @Override
         public void onEnable() {
-            registerOperator("+", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
-                    0, subtractFunction));
-            registerOperator("-", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
-                    0, subtractFunction));
+            registerOperator("+", new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
+                    0) {
+
+                @Override
+                public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+                    return true;
+                }
+
+                @Override
+                public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+                    return subtractFunction.apply(implementation, params);
+                }
+            });
+            registerOperator("-", new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
+                    0) {
+
+                @Override
+                public boolean matchesParams(NumberImplementation implementation, NumberInterface[] params) {
+                    return true;
+                }
+
+                @Override
+                public NumberInterface applyInternal(NumberImplementation implementation, NumberInterface[] params) {
+                    return subtractFunction.apply(implementation, params);
+                }
+            });
             registerFunction("subtract", subtractFunction);
         }
 

docs/_layouts/home.html

@@ -3,7 +3,8 @@
   {% include head.html %}
   <style>
   body {
-    margin-top: 100px;
+    margin: 0px;
+    margin-top: 50px;
     color: white;
     text-align: center;
   }
@@ -11,7 +12,13 @@
     font-family: "Source Code Pro"
   }
 
-  img {
+  img#logo {
+    margin: auto;
+    width: 100%;
+    max-width: 100px;
+  }
+
+  img#image_preview {
     margin: auto;
     width: 100%;
     max-width: 432px;
@@ -31,8 +38,61 @@
     background-color: #06e8a4;
     color: white;
   }
+
+  div.fullwidth {
+    width: 100%;
+    height: auto;
+    overflow: hidden;
+  }
+
+  div.fullwidth img {
+    max-width: 100%;
+    max-height: 450px;
+    margin: auto;
+    margin-top: 20px;
+    margin-bottom: 20px;
+    display: block;
+    border-radius: 5px;
+  }
+
+  div.white {
+    background-color: white;
+    color: black;
+  }
+
+  div.green {
+    background-color: #06e8a4;
+    color: white;
+  }
+
+  div.fullwidth div.double {
+    height: 100%;
+    text-align: left;
+    width: 50%;
+    box-sizing: border-box;
+    padding: 40px;
+    float: left;
+    background-color: inherit;
+  }
+
+  @media (max-width: 750px) {
+    div.fullwidth div.double {
+      width: 100%;
+      padding: 15px;
+    }
+    div.fullwidth img {
+      margin-top: 0px;
+      margin-bottom: 0px;
+    }
+  }
+
+  div.fullwidth div.double h1, h2, h3, h4, h5, h6 {
+    text-align: center;
+  }
+
   </style>
   <body>
+  <img src="https://raw.githubusercontent.com/DanilaFe/abacus/master/image/logo.png" id="logo">
   <h1>Abacus</h1>
   <h2>The programmer's calculator</h2>
   <div id="buttons">
@@ -41,6 +101,59 @@
     <a class="button inverted" href="https://github.com/DanilaFe/abacus">Contribute</a>
     <a class="button inverted" href="https://github.com/DanilaFe/abacus/wiki">Wiki</a>
   </div>
-  <img src="http://i.imgur.com/Min70QY.png" title="source: imgur.com" />
+  <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

@@ -14,8 +14,8 @@ import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.config.Configuration;
 import org.nwapw.abacus.function.Documentation;
 import org.nwapw.abacus.function.DocumentationType;
-import org.nwapw.abacus.number.ComputationInterruptedException;
-import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.function.DomainException;
+import org.nwapw.abacus.number.*;
 import org.nwapw.abacus.plugin.ClassFinder;
 import org.nwapw.abacus.plugin.PluginListener;
 import org.nwapw.abacus.plugin.PluginManager;
@@ -153,6 +153,8 @@ public class AbacusController implements PluginListener {
                 return resultingString;
             } catch (ComputationInterruptedException exception) {
                 return ERR_STOP;
+            } catch (DomainException exception) {
+                return exception.getMessage();
             } catch (RuntimeException exception) {
                 exception.printStackTrace();
                 return ERR_EXCEPTION;
@@ -195,7 +197,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 +257,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);
@@ -337,8 +339,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;
     }
@@ -360,6 +362,8 @@ public class AbacusController implements PluginListener {
         PluginManager pluginManager = abacus.getPluginManager();
         functionList.addAll(manager.getAllFunctions().stream().map(name -> pluginManager.documentationFor(name, DocumentationType.FUNCTION))
                 .collect(Collectors.toCollection(ArrayList::new)));
+        functionList.addAll(manager.getAllTreeValueFunctions().stream().map(name -> pluginManager.documentationFor(name, DocumentationType.TREE_VALUE_FUNCTION))
+                .collect(Collectors.toCollection(ArrayList::new)));
         functionList.sort(Comparator.comparing(Documentation::getCodeName));
     }
 

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

@@ -0,0 +1,70 @@
+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() {
+        copyFrom(Toml(DEFAULT_TOML_READER).read(tomlFile).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)
+    }
+
+}