Fix not clearing an important map during reset.

Add a Logo.
Sorry Arthur, there's literally no reason to wait for approval on this one.

build.gradle

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

core/build.gradle

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

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

@@ -2,6 +2,7 @@ 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;
@@ -42,6 +43,10 @@ public class Abacus {
      * from a string.
      */
     private TreeBuilder treeBuilder;
+    /**
+     * Promotion manager responsible for the promotion system.
+     */
+    private PromotionManager promotionManager;
 
     /**
      * Creates a new instance of the Abacus calculator.
@@ -53,11 +58,22 @@ public class Abacus {
         numberReducer = new NumberReducer(this);
         this.configuration = new Configuration(configuration);
         LexerTokenizer lexerTokenizer = new LexerTokenizer();
-        ShuntingYardParser shuntingYardParser = new ShuntingYardParser(this);
+        ShuntingYardParser shuntingYardParser = new ShuntingYardParser();
         treeBuilder = new TreeBuilder<>(lexerTokenizer, shuntingYardParser);
+        promotionManager = new PromotionManager(this);
 
         pluginManager.addListener(shuntingYardParser);
         pluginManager.addListener(lexerTokenizer);
+        pluginManager.addListener(promotionManager);
+    }
+
+    /**
+     * Gets the promotion manager.
+     *
+     * @return the promotion manager.
+     */
+    public PromotionManager getPromotionManager() {
+        return promotionManager;
     }
 
     /**
@@ -120,16 +136,15 @@ public class Abacus {
     }
 
     /**
-     * Creates a number from a string.
+     * Gets the number implementation.
      *
-     * @param numberString the string to create the number from.
-     * @return the resulting number.
+     * @return the number implementation to use for creating numbers.
      */
-    public NumberInterface numberFromString(String numberString) {
-        NumberImplementation toInstantiate =
+    public NumberImplementation getNumberImplementation() {
+        NumberImplementation selectedImplementation =
                 pluginManager.numberImplementationFor(configuration.getNumberImplementation());
-        if (toInstantiate == null) toInstantiate = DEFAULT_IMPLEMENTATION;
-
-        return toInstantiate.instanceForString(numberString);
+        if (selectedImplementation != null) return selectedImplementation;
+        return DEFAULT_IMPLEMENTATION;
     }
+
 }

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

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

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

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

core/src/main/java/org/nwapw/abacus/number/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,9 +1,6 @@
 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;
 
 /**
@@ -65,10 +62,21 @@ public abstract class Plugin {
      * @param name       the name to register by.
      * @param toRegister the function implementation.
      */
-    protected final void registerFunction(String name, Function toRegister) {
+    protected final void registerFunction(String name, NumberFunction toRegister) {
         manager.registerFunction(name, toRegister);
     }
 
+    /**
+     * To be used in load(). Registers a tree value function abstract class
+     * with the plugin internally, which makes it accessible to the plugin manager.
+     *
+     * @param name       the name to register by.
+     * @param toRegister the tree value function implementation.
+     */
+    protected final void registerTreeValueFunction(String name, TreeValueFunction toRegister) {
+        manager.registerTreeValueFunction(name, toRegister);
+    }
+
     /**
      * To be used in load(). Registers an operator abstract class
      * with the plugin internally, which makes it accessible to
@@ -77,10 +85,22 @@ public abstract class Plugin {
      * @param name     the name of the operator.
      * @param operator the operator to register.
      */
-    protected final void registerOperator(String name, Operator operator) {
+    protected final void registerOperator(String name, NumberOperator operator) {
         manager.registerOperator(name, operator);
     }
 
+    /**
+     * To be used in load(). Registers an operator
+     * with the plugin internally, which makes it accessible
+     * to the plugin manager.
+     *
+     * @param name     the name of the tree value operator.
+     * @param operator the tree value operator to register.
+     */
+    protected final void registerTreeValueOperator(String name, TreeValueOperator operator) {
+        manager.registerTreeValueOperator(name, operator);
+    }
+
     /**
      * To be used in load(). Registers a new number implementation with the plugin.
      * This makes it accessible to the plugin manager.
@@ -110,10 +130,22 @@ public abstract class Plugin {
      * @param name the name for which to search
      * @return the resulting function, or null if none was found for that name.
      */
-    protected final Function functionFor(String name) {
+    protected final NumberFunction functionFor(String name) {
         return manager.functionFor(name);
     }
 
+    /**
+     * Searches the PluginManager for the given function name.
+     * This can be used by the plugins internally in order to call functions
+     * they do not provide.
+     *
+     * @param name the name for which to search.
+     * @return the resulting tree value function, or null if none was found for that name.
+     */
+    protected final TreeValueFunction treeValueFunctionFor(String name) {
+        return manager.treeValueFunctionFor(name);
+    }
+
     /**
      * Searches the PluginManager for the given operator name.
      * This can be used by the plugins internally in order to call
@@ -122,10 +154,22 @@ public abstract class Plugin {
      * @param name the name for which to search
      * @return the resulting operator, or null if none was found for that name.
      */
-    protected final Operator operatorFor(String name) {
+    protected final NumberOperator operatorFor(String name) {
         return manager.operatorFor(name);
     }
 
+    /**
+     * Searches the PluginManager for the given tree value operator name.
+     * This can be used by the plugins internally in order to call
+     * operations they do not provide.
+     *
+     * @param name the name for which to search.
+     * @return the resulting tree value operator, or null if none was found for that name.
+     */
+    protected final TreeValueOperator treeValueOperatorFor(String name) {
+        return manager.treeValueOperatorFor(name);
+    }
+
     /**
      * Searches the PluginManager for the given number implementation
      * name. This can be used by the plugins internally in order to find

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

@@ -1,10 +1,7 @@
 package org.nwapw.abacus.plugin;
 
 import org.nwapw.abacus.Abacus;
-import org.nwapw.abacus.function.Documentation;
-import org.nwapw.abacus.function.DocumentationType;
-import org.nwapw.abacus.function.Function;
-import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.*;
 import org.nwapw.abacus.number.NumberInterface;
 
 import java.lang.reflect.InvocationTargetException;
@@ -30,11 +27,19 @@ public class PluginManager {
     /**
      * The map of functions registered by the plugins.
      */
-    private Map<String, Function> registeredFunctions;
+    private Map<String, NumberFunction> registeredFunctions;
+    /**
+     * The map of tree value functions regstered by the plugins.
+     */
+    private Map<String, TreeValueFunction> registeredTreeValueFunctions;
     /**
      * The map of operators registered by the plugins
      */
-    private Map<String, Operator> registeredOperators;
+    private Map<String, NumberOperator> registeredOperators;
+    /**
+     * The map of tree value operators registered by the plugins.
+     */
+    private Map<String, TreeValueOperator> registeredTreeValueOperators;
     /**
      * The map of number implementations registered by the plugins.
      */
@@ -44,10 +49,13 @@ public class PluginManager {
      */
     private Set<Documentation> registeredDocumentation;
     /**
-     * The list of number implementations that have been
-     * found by their implementation class.
+     * The list of number implementation names.
      */
-    private Map<Class<? extends NumberInterface>, NumberImplementation> cachedInterfaceImplementations;
+    private Map<Class<? extends NumberInterface>, String> interfaceImplementationNames;
+    /**
+     * The list of number implementations.
+     */
+    private Map<Class<? extends NumberInterface>, NumberImplementation> interfaceImplementations;
     /**
      * The pi values for each implementation class that have already been computer.
      */
@@ -72,10 +80,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 +97,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 +139,8 @@ public class PluginManager {
      */
     public void registerNumberImplementation(String name, NumberImplementation implementation) {
         registeredNumberImplementations.put(name, implementation);
+        interfaceImplementationNames.put(implementation.getImplementation(), name);
+        interfaceImplementations.put(implementation.getImplementation(), implementation);
     }
 
     /**
@@ -126,20 +159,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 +232,17 @@ public class PluginManager {
      * @return the implementation.
      */
     public NumberImplementation interfaceImplementationFor(Class<? extends NumberInterface> name) {
-        if (cachedInterfaceImplementations.containsKey(name)) return cachedInterfaceImplementations.get(name);
-        NumberImplementation toReturn = null;
-        for (String key : registeredNumberImplementations.keySet()) {
-            NumberImplementation implementation = registeredNumberImplementations.get(key);
-            if (implementation.getImplementation() == name) {
-                toReturn = implementation;
-                break;
-            }
-        }
-        cachedInterfaceImplementations.put(name, toReturn);
-        return toReturn;
+        return interfaceImplementations.get(name);
+    }
+
+    /**
+     * Gets the number implementation name for the given implementation class.
+     *
+     * @param name the class for which to find the implementation name.
+     * @return the implementation name.
+     */
+    public String interfaceImplementationNameFor(Class<? extends NumberInterface> name) {
+        return interfaceImplementationNames.get(name);
     }
 
     /**
@@ -277,10 +330,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 +358,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 +376,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.
      *

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

@@ -7,7 +7,6 @@ import org.nwapw.abacus.number.PreciseNumber;
 
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.function.BiFunction;
 
 /**
  * The plugin providing standard functions such as addition and subtraction to
@@ -18,83 +17,60 @@ public class StandardPlugin extends Plugin {
     /**
      * The addition operator, +
      */
-    public static final Operator OP_ADD = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
+    public static final NumberOperator OP_ADD = new NumberOperator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0) {
         @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length >= 1;
-        }
-
-        @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;
-        }
-    });
-    /**
-     * The subtraction operator, -
-     */
-    public static final Operator OP_SUBTRACT = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
-        @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].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 +96,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 +121,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 +166,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 +257,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 +266,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 +286,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 +309,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 +334,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 +405,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 +534,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 +623,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 +640,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 +670,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 +689,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);
@@ -832,6 +787,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,13 @@
 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;
 
 /**
  * A reducer implementation that turns a tree into a single number.
@@ -26,27 +31,54 @@ 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) {
+            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/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,42 @@
+package org.nwapw.abacus.function.applicable
+
+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)) return null
+        return applyInternal(implementation, params)
+    }
+
+}

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

@@ -0,0 +1,44 @@
+package org.nwapw.abacus.function.applicable
+
+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)) return null
+        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/test/java/org/nwapw/abacus/tests/CalculationTests.java

@@ -101,7 +101,7 @@ public class CalculationTests {
         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)");
+        testEvalError("(-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;
 
@@ -21,24 +19,46 @@ public class TokenizerTests {
 
     private static Abacus abacus = new Abacus(new Configuration(0, "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,7 @@
   {% include head.html %}
   <style>
   body {
-    margin-top: 100px;
+    margin-top: 50px;
     color: white;
     text-align: center;
   }
@@ -11,8 +11,16 @@
     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;
   }
 
   div#buttons {
@@ -31,6 +39,7 @@
   }
   </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">
@@ -39,6 +48,6 @@
     <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"/>
   </body>
 </html>

docs/_pages/about.md

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

docs/assets/css/main.scss

@@ -16,6 +16,7 @@ a {
   color: $background-color;
 
   &.button {
+    display: inline-block;
     background-color: $background-color;
     color: $clear-color;
     padding: 10px;

fx/build.gradle

@@ -1,6 +1,3 @@
-plugins {
-    id 'org.jetbrains.kotlin.jvm' version '1.1.3'
-}
 apply plugin: 'application'
 
 dependencies {

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

@@ -14,8 +14,7 @@ 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.number.*;
 import org.nwapw.abacus.plugin.ClassFinder;
 import org.nwapw.abacus.plugin.PluginListener;
 import org.nwapw.abacus.plugin.PluginManager;
@@ -360,6 +359,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));
     }