Implement preciseNumber for arbitrary precision.

src/org/nwapw/abacus/function/Operator.java

@@ -3,7 +3,7 @@ package org.nwapw.abacus.function;
 /**
  * A class that represents a single infix operator.
  */
-public abstract class Operator {
+public class Operator {
 
     /**
      * The associativity of the operator.

src/org/nwapw/abacus/lexing/Lexer.java

@@ -54,7 +54,7 @@ public class Lexer<T> {
     /**
      * The registered patterns.
      */
-    private HashMap<PatternEntry<T>, Pattern<T>> patterns;
+    private Map<PatternEntry<T>, Pattern<T>> patterns;
 
     /**
      * Creates a new lexer with no registered patterns.
@@ -127,7 +127,7 @@ public class Lexer<T> {
      * @param compare the comparator used to sort matches by their IDs.
      * @return the resulting list of matches, in order, or null on error.
      */
-    public ArrayList<Match<T>> lexAll(String from, int startAt, Comparator<T> compare){
+    public List<Match<T>> lexAll(String from, int startAt, Comparator<T> compare){
         int index = startAt;
         ArrayList<Match<T>> matches = new ArrayList<>();
         Match<T> lastMatch = null;

src/org/nwapw/abacus/lexing/pattern/Pattern.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.Map;
 import java.util.Stack;
 import java.util.function.Function;
 
@@ -32,7 +33,7 @@ public class Pattern<T> {
      * A map of regex operator to functions that modify a PatternChain
      * with the appropriate operation.
      */
-    private HashMap<Character, Function<PatternChain<T>, PatternChain<T>>> operations =
+    private Map<Character, Function<PatternChain<T>, PatternChain<T>>> operations =
             new HashMap<Character, Function<PatternChain<T>, PatternChain<T>>>() {{
                 put('+', Pattern.this::transformPlus);
                 put('*', Pattern.this::transformStar);
@@ -235,4 +236,22 @@ public class Pattern<T> {
     public PatternNode<T> getHead() {
         return head;
     }
+
+    /**
+     * Removes all characters that are considered "special" from
+     * the given string.
+     * @param from the string to sanitize.
+     * @return the resulting string.
+     */
+    public static String sanitize(String from){
+        Pattern<Integer> pattern = new Pattern<>("", 0);
+        from = from.replace(".", "\\.");
+        from = from.replace("|", "\\|");
+        from = from.replace("(", "\\(");
+        from = from.replace(")", "\\)");
+        for(Character key : pattern.operations.keySet()){
+            from = from.replace("" + key, "\\" + key);
+        }
+        return from;
+    }
 }

src/org/nwapw/abacus/lexing/pattern/PatternNode.java

@@ -3,6 +3,7 @@ package org.nwapw.abacus.lexing.pattern;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
+import java.util.Set;
 
 /**
  * A base class for a pattern node. Provides all functions
@@ -16,7 +17,7 @@ public class PatternNode<T> {
      * The set of states to which the lexer should continue
      * should this node be correctly matched.
      */
-    protected HashSet<PatternNode<T>> outputStates;
+    protected Set<PatternNode<T>> outputStates;
 
     /**
      * Creates a new pattern node.

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

@@ -29,7 +29,7 @@ public class NaiveNumber implements NumberInterface {
 
     @Override
     public int precision() {
-        return 15;
+        return 18;
     }
 
     @Override
@@ -88,6 +88,9 @@ public class NaiveNumber implements NumberInterface {
     @Override
     public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
         if(toClass == this.getClass()) return this;
+        else if(toClass == PreciseNumber.class){
+            return new PreciseNumber(Double.toString(value));
+        }
         return null;
     }
 

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

@@ -0,0 +1,112 @@
+package org.nwapw.abacus.number;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.MathContext;
+import java.math.RoundingMode;
+
+public class PreciseNumber implements NumberInterface{
+
+    /**
+     * The number one.
+     */
+    static final PreciseNumber ONE = new PreciseNumber(BigDecimal.ONE);
+    /**
+     * The number zero.
+     */
+    static final PreciseNumber ZERO = new PreciseNumber(BigDecimal.ZERO);
+    /**
+     * The number ten.
+     */
+    static final PreciseNumber TEN = new PreciseNumber(BigDecimal.TEN);
+
+    BigDecimal value = new BigDecimal("0");
+
+    /**
+     * Constructs a precise number from the given string.
+     * @param string a string representation of the number meeting the same conditions
+     *               as the BidDecimal(String) constructor.
+     */
+    public PreciseNumber(String string){
+        value = new BigDecimal(string);
+    }
+
+    /**
+     * Constructs a precise number from the given BigDecimal.
+     * @param value a BigDecimal object representing the value of the number.
+     */
+    public PreciseNumber(BigDecimal value){
+        this.value = value;
+    }
+
+    @Override
+    public int precision() {
+        return 54;
+    }
+
+    @Override
+    public NumberInterface multiply(NumberInterface multiplier) {
+        return new PreciseNumber(value.multiply(((PreciseNumber) multiplier).value));
+    }
+
+    @Override
+    public NumberInterface divide(NumberInterface divisor) {
+        return new PreciseNumber(value.divide(((PreciseNumber) divisor).value, this.precision(), RoundingMode.HALF_UP));
+    }
+
+    @Override
+    public NumberInterface add(NumberInterface summand) {
+        return new PreciseNumber(value.add(((PreciseNumber) summand).value));
+    }
+
+    @Override
+    public NumberInterface subtract(NumberInterface subtrahend) {
+        return new PreciseNumber(value.subtract(((PreciseNumber) subtrahend).value));
+    }
+
+    @Override
+    public NumberInterface intPow(int exponent) {
+        if(exponent == 0){
+            return PreciseNumber.ONE;
+        }
+        boolean takeReciprocal = exponent < 0;
+        exponent = Math.abs(exponent);
+        NumberInterface power = this;
+        for(int currentExponent = 1; currentExponent < exponent; currentExponent++){
+            power = power.multiply(this);
+        }
+        if(takeReciprocal){
+            power = PreciseNumber.ONE.divide(power);
+        }
+        return power;
+    }
+
+    @Override
+    public int compareTo(NumberInterface number) {
+        return value.compareTo(((PreciseNumber) number).value);
+    }
+
+    @Override
+    public int signum() {
+        return value.signum();
+    }
+
+    @Override
+    public NumberInterface negate(){
+        return new PreciseNumber(value.negate());
+    }
+
+    @Override
+    public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
+        if(toClass == this.getClass()){
+            return this;
+        }
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        BigDecimal rounded = value.setScale(precision() - 4, RoundingMode.HALF_UP);
+        return rounded.stripTrailingZeros().toPlainString();
+    }
+}

src/org/nwapw/abacus/plugin/ClassFinder.java

@@ -0,0 +1,65 @@
+package org.nwapw.abacus.plugin;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.zip.ZipInputStream;
+
+public class ClassFinder extends ClassLoader{
+
+    ArrayList<Class> classes;
+
+    public ClassFinder(){
+        super(ClassFinder.class.getClassLoader());
+        classes=new ArrayList();
+    }
+    public Class loadClass(String className) throws ClassNotFoundException{
+        return findClass(className);
+    }
+    public ArrayList<String> loadClass(File jarLocation) throws ClassNotFoundException, IOException{
+        return addJar(jarLocation);
+    }
+    public ArrayList<String> addJar(File jarLocation) throws IOException {
+        JarFile jarFolder = new JarFile(jarLocation);
+        Enumeration jarList = jarFolder.entries();
+        HashMap classSize = new HashMap();
+        HashMap classContent = new HashMap();
+        ArrayList<String> classNames = new ArrayList();
+        JarEntry tempJar;
+        ZipInputStream zipStream = new ZipInputStream(new BufferedInputStream(new FileInputStream(jarLocation)));
+        while(jarList.hasMoreElements()){
+            tempJar = (JarEntry)jarList.nextElement();
+            zipStream.getNextEntry();
+            if(!tempJar.isDirectory()) {
+                if (tempJar.getName().substring(tempJar.getName().indexOf('.')).equals(".class") && (tempJar.getName().length() < 9 || !tempJar.getName().substring(0, 9).equals("META-INF/"))) {
+                    int size = (int)tempJar.getSize();
+                    classSize.put(tempJar.getName(),new Integer((int)tempJar.getSize()));
+                    byte[] bytes = new byte[size];
+                    zipStream.read(bytes,0,size);
+                    classContent.put(tempJar.getName(),bytes);
+                    classNames.add(tempJar.getName());
+                }
+            }
+        }
+        jarFolder.close();
+        for(String name:classNames) {
+            classes.add(super.defineClass(name, (byte[]) classContent.get(name), 0, (int) classSize.get(name)));
+        }
+        return classNames;
+    }
+    public ArrayList<Class> getClasses(){
+        return classes;
+    }
+    public Class getClass(int number){
+        return classes.get(number);
+    }
+    public void delClasses(){
+        classes=new ArrayList();
+    }
+}

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

@@ -4,6 +4,7 @@ import org.nwapw.abacus.function.Function;
 import org.nwapw.abacus.function.Operator;
 
 import java.util.HashMap;
+import java.util.Map;
 import java.util.Set;
 
 /**
@@ -18,11 +19,11 @@ public abstract class Plugin {
     /**
      * A hash map of functions mapped to their string names.
      */
-    private HashMap<String, Function> functions;
+    private Map<String, Function> functions;
     /**
      * A hash map of operators mapped to their string names.
      */
-    private HashMap<String, Operator> operators;
+    private Map<String, Operator> operators;
     /**
      * The plugin manager in which to search for functions
      * not inside this package,

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

@@ -15,29 +15,29 @@ public class PluginManager {
     /**
      * A list of loaded plugins.
      */
-    private ArrayList<Plugin> plugins;
+    private List<Plugin> plugins;
     /**
      * List of functions that have been cached,
      * that is, found in a plugin and returned.
      */
-    private HashMap<String, Function> cachedFunctions;
+    private Map<String, Function> cachedFunctions;
     /**
      * List of operators tha have been cached,
      * that is, found in a plugin and returned.
      */
-    private HashMap<String, Operator> cachedOperators;
+    private Map<String, Operator> cachedOperators;
     /**
      * List of all functions loaded by the plugins.
      */
-    private HashSet<String> allFunctions;
+    private Set<String> allFunctions;
     /**
      * List of all operators loaded by the plugins.
      */
-    private HashSet<String> allOperators;
+    private Set<String> allOperators;
     /**
      * The list of plugin listeners attached to this instance.
      */
-    private HashSet<PluginListener> listeners;
+    private Set<PluginListener> listeners;
 
     /**
      * Creates a new plugin manager.
@@ -155,7 +155,7 @@ public class PluginManager {
      * Gets all the functions loaded by the Plugin Manager.
      * @return the set of all functions that were loaded.
      */
-    public HashSet<String> getAllFunctions() {
+    public Set<String> getAllFunctions() {
         return allFunctions;
     }
 
@@ -163,7 +163,7 @@ public class PluginManager {
      * Gets all the operators loaded by the Plugin Manager.
      * @return the set of all operators that were loaded.
      */
-    public HashSet<String> getAllOperators() {
+    public Set<String> getAllOperators() {
         return allOperators;
     }
 

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

@@ -1,6 +1,8 @@
 package org.nwapw.abacus.plugin;
 
 import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.OperatorAssociativity;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 
@@ -18,7 +20,7 @@ public class StandardPlugin extends Plugin {
 
     @Override
     public void onEnable() {
-        registerFunction("+", new Function() {
+        registerOperator("+", new Operator(OperatorAssociativity.LEFT, 0, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length >= 1;
@@ -32,9 +34,9 @@ public class StandardPlugin extends Plugin {
                 }
                 return sum;
             }
-        });
+        }));
 
-        registerFunction("-", new Function() {
+        registerOperator("-", new Operator(OperatorAssociativity.LEFT, 0, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length == 2;
@@ -44,9 +46,9 @@ public class StandardPlugin extends Plugin {
             protected NumberInterface applyInternal(NumberInterface[] params) {
                 return params[0].subtract(params[1]);
             }
-        });
+        }));
 
-        registerFunction("*", new Function() {
+        registerOperator("*", new Operator(OperatorAssociativity.LEFT, 1, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length >= 1;
@@ -60,9 +62,9 @@ public class StandardPlugin extends Plugin {
                 }
                 return product;
             }
-        });
+        }));
 
-        registerFunction("/", new Function() {
+        registerOperator("/", new Operator(OperatorAssociativity.LEFT, 1, new Function() {
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length == 2;
@@ -72,9 +74,22 @@ public class StandardPlugin extends Plugin {
             protected NumberInterface applyInternal(NumberInterface[] params) {
                 return params[0].divide(params[1]);
             }
-        });
+        }));
+
+        registerOperator("^", new Operator(OperatorAssociativity.RIGHT, 2, new Function() {
+            @Override
+            protected boolean matchesParams(NumberInterface[] params) {
+                return params.length == 2;
+            }
+
+            @Override
+            protected NumberInterface applyInternal(NumberInterface[] params) {
+                return StandardPlugin.this.getFunction("exp").apply(StandardPlugin.this.getFunction("ln").apply(params[0]).multiply(params[1]));
+            }
+        }));
 
         registerFunction("!", new Function() {
+            //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
             @Override
             protected boolean matchesParams(NumberInterface[] params) {
                 return params.length == 1;
@@ -92,6 +107,23 @@ public class StandardPlugin extends Plugin {
                     factorial = factorial.multiply(multiplier);
                 }
                 return factorial;
+                /*if(!storedList.containsKey(params[0].getClass())){
+                    storedList.put(params[0].getClass(), new ArrayList<NumberInterface>());
+                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
+                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
+                }*/
+            }
+        });
+
+        registerFunction("abs", new Function() {
+            @Override
+            protected boolean matchesParams(NumberInterface[] params) {
+                return params.length == 1;
+            }
+
+            @Override
+            protected NumberInterface applyInternal(NumberInterface[] params) {
+                return params[0].multiply((new NaiveNumber(params[0].signum())).promoteTo(params[0].getClass()));
             }
         });
 
@@ -103,7 +135,100 @@ public class StandardPlugin extends Plugin {
 
             @Override
             protected NumberInterface applyInternal(NumberInterface[] params) {
-                return sumSeries(params[0], StandardPlugin.this::getExpSeriesTerm, getNTermsExp(getMaxError(params[0]), params[0]));
+                boolean takeReciprocal = params[0].signum() == -1;
+                params[0] = StandardPlugin.this.getFunction("abs").apply(params[0]);
+                NumberInterface sum = sumSeries(params[0], StandardPlugin.this::getExpSeriesTerm, getNTermsExp(getMaxError(params[0]), params[0]));
+                if(takeReciprocal){
+                    sum = NaiveNumber.ONE.promoteTo(sum.getClass()).divide(sum);
+                }
+                return sum;
+            }
+        });
+
+        registerFunction("ln", new Function() {
+            @Override
+            protected boolean matchesParams(NumberInterface[] params) {
+                return params.length == 1;
+            }
+
+            @Override
+            protected NumberInterface applyInternal(NumberInterface[] params) {
+                NumberInterface param = params[0];
+                int powersOf2 = 0;
+                while(StandardPlugin.this.getFunction("abs").apply(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass()))).compareTo((new NaiveNumber(0.1)).promoteTo(param.getClass())) >= 0){
+                    if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() == 1) {
+                        param = param.divide(new NaiveNumber(2).promoteTo(param.getClass()));
+                        powersOf2++;
+                        if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                            break;
+                            //No infinite loop for you.
+                        }
+                    }
+                    else {
+                        param = param.multiply(new NaiveNumber(2).promoteTo(param.getClass()));
+                        powersOf2--;
+                        if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                            break;
+                            //No infinite loop for you.
+                        }
+                    }
+                }
+                return getLog2(param).multiply((new NaiveNumber(powersOf2)).promoteTo(param.getClass())).add(getLogPartialSum(param));
+            }
+
+            /**
+             * Returns the partial sum of the Taylor series for logx (around x=1).
+             * Automatically determines the number of terms needed based on the precision of x.
+             * @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){
+                NumberInterface maxError = StandardPlugin.this.getMaxError(x);
+                x = x.subtract(NaiveNumber.ONE.promoteTo(x.getClass())); //Terms used are for log(x+1).
+                NumberInterface currentTerm = x, sum = x;
+                int n = 1;
+                while(StandardPlugin.this.getFunction("abs").apply(currentTerm).compareTo(maxError) > 0){
+                    n++;
+                    currentTerm = currentTerm.multiply(x).multiply((new NaiveNumber(n-1)).promoteTo(x.getClass())).divide((new NaiveNumber(n)).promoteTo(x.getClass())).negate();
+                    sum = sum.add(currentTerm);
+                }
+                return sum;
+            }
+
+            /**
+             * Returns natural log of 2 to the required precision of the class of number.
+             * @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){
+                NumberInterface maxError = StandardPlugin.this.getMaxError(number);
+                //NumberInterface errorBound = (new NaiveNumber(1)).promoteTo(number.getClass());
+                //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 = (new NaiveNumber(1)).promoteTo(number.getClass()), b = a, c = a;
+                NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClass());
+                int n = 0;
+                while(a.compareTo(maxError) >= 1){
+                    n++;
+                    a = a.divide((new NaiveNumber(3)).promoteTo(number.getClass()));
+                    b = b.divide((new NaiveNumber(4)).promoteTo(number.getClass()));
+                    c = NaiveNumber.ONE.promoteTo(number.getClass()).divide((new NaiveNumber(n)).promoteTo(number.getClass()));
+                    sum = sum.add(a.add(b).multiply(c));
+                }
+                return sum;
+            }
+        });
+
+        registerFunction("sqrt", new Function() {
+            @Override
+            protected boolean matchesParams(NumberInterface[] params) {
+                return params.length == 1;
+            }
+
+            @Override
+            protected NumberInterface applyInternal(NumberInterface[] params) {
+                return StandardPlugin.this.getOperator("^").getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
             }
         });
     }
@@ -130,15 +255,16 @@ public class StandardPlugin extends Plugin {
      * @param x where the function is evaluated.
      * @return the number of terms needed to evaluated the exponential function.
      */
-    private int getNTermsExp(NumberInterface maxError, NumberInterface x){
-        //We need n such that x^(n+2) <= (n+1)! * maxError
+    private int getNTermsExp(NumberInterface maxError, NumberInterface x) {
+        //We need n such that |x^(n+1)| <= (n+1)! * maxError
         //The variables LHS and RHS refer to the above inequality.
         int n = 0;
-        NumberInterface LHS = x.intPow(2), RHS = maxError;
-        while(LHS.compareTo(RHS) > 0){
+        x = this.getFunction("abs").apply(x);
+        NumberInterface LHS = x, RHS = maxError;
+        while (LHS.compareTo(RHS) > 0) {
             n++;
             LHS = LHS.multiply(x);
-            RHS = RHS.multiply(new NaiveNumber(n).promoteTo(RHS.getClass()));
+            RHS = RHS.multiply(new NaiveNumber(n + 1).promoteTo(RHS.getClass()));
         }
         return n;
     }

src/org/nwapw/abacus/tree/FunctionNode.java

@@ -1,6 +1,7 @@
 package org.nwapw.abacus.tree;
 
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * A node that represents a function call.
@@ -14,7 +15,7 @@ public class FunctionNode extends TreeNode {
     /**
      * The list of arguments to the function.
      */
-    private ArrayList<TreeNode> children;
+    private List<TreeNode> children;
 
     /**
      * Creates a function node with no function.
@@ -39,13 +40,21 @@ public class FunctionNode extends TreeNode {
     }
 
     /**
-     * Adds a child to this node.
+     * Adds a child to the end of this node's child list.
      * @param node the child to add.
      */
-    public void addChild(TreeNode node){
+    public void appendChild(TreeNode node){
         children.add(node);
     }
 
+    /**
+     * Adds a new child to the beginning of this node's child list.
+     * @param node the node to add.
+     */
+    public void prependChild(TreeNode node) {
+        children.add(0, node);
+    }
+
     @Override
     public <T> T reduce(Reducer<T> reducer) {
         Object[] reducedChildren = new Object[children.size()];

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

@@ -30,7 +30,7 @@ public class NumberReducer implements Reducer<NumberInterface> {
         } else if(node instanceof OpNode){
             NumberInterface left = (NumberInterface) children[0];
             NumberInterface right = (NumberInterface) children[1];
-            Function function = manager.functionFor(((OpNode) node).getOperation());
+            Function function = manager.operatorFor(((OpNode) node).getOperation()).getFunction();
             if(function == null) return null;
             return function.apply(left, right);
         } else if(node instanceof FunctionNode){

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

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

src/org/nwapw/abacus/tree/TreeBuilder.java

@@ -3,6 +3,7 @@ package org.nwapw.abacus.tree;
 import org.nwapw.abacus.function.OperatorAssociativity;
 import org.nwapw.abacus.lexing.Lexer;
 import org.nwapw.abacus.lexing.pattern.Match;
+import org.nwapw.abacus.lexing.pattern.Pattern;
 
 import java.util.*;
 
@@ -18,11 +19,11 @@ public class TreeBuilder {
     /**
      * The map of operator precedences.
      */
-    private HashMap<String, Integer> precedenceMap;
+    private Map<String, Integer> precedenceMap;
     /**
      * The map of operator associativity.
      */
-    private HashMap<String, OperatorAssociativity> associativityMap;
+    private Map<String, OperatorAssociativity> associativityMap;
 
     /**
      * Comparator used to sort token types.
@@ -34,6 +35,7 @@ public class TreeBuilder {
      */
     public TreeBuilder(){
         lexer = new Lexer<TokenType>(){{
+            register(" ", TokenType.WHITESPACE);
             register(",", TokenType.COMMA);
             register("[0-9]+(\\.[0-9]+)?", TokenType.NUM);
             register("\\(", TokenType.OPEN_PARENTH);
@@ -48,7 +50,7 @@ public class TreeBuilder {
      * @param function the function to register.
      */
     public void registerFunction(String function){
-        lexer.register(function, TokenType.FUNCTION);
+        lexer.register(Pattern.sanitize(function), TokenType.FUNCTION);
     }
 
     /**
@@ -58,7 +60,7 @@ public class TreeBuilder {
      * @param associativity the associativity of the operator.
      */
     public void registerOperator(String operator, int precedence, OperatorAssociativity associativity){
-        lexer.register(operator, TokenType.OP);
+        lexer.register(Pattern.sanitize(operator), TokenType.OP);
         precedenceMap.put(operator, precedence);
         associativityMap.put(operator, associativity);
     }
@@ -68,7 +70,7 @@ public class TreeBuilder {
      * @param string the string to tokenize.
      * @return the list of tokens produced.
      */
-    public ArrayList<Match<TokenType>> tokenize(String string){
+    public List<Match<TokenType>> tokenize(String string){
         return lexer.lexAll(string, 0, tokenSorter);
     }
 
@@ -78,7 +80,7 @@ public class TreeBuilder {
      * @param from the tokens to be rearranged.
      * @return the resulting list of rearranged tokens.
      */
-    public ArrayList<Match<TokenType>> intoPostfix(String source, ArrayList<Match<TokenType>> from){
+    public List<Match<TokenType>> intoPostfix(String source, List<Match<TokenType>> from){
         ArrayList<Match<TokenType>> output = new ArrayList<>();
         Stack<Match<TokenType>> tokenStack = new Stack<>();
         while(!from.isEmpty()){
@@ -97,13 +99,15 @@ public class TreeBuilder {
                 while(!tokenStack.empty()) {
                     Match<TokenType> otherMatch = tokenStack.peek();
                     TokenType otherMatchType = otherMatch.getType();
-                    if(otherMatchType != TokenType.OP) break;
+                    if(!(otherMatchType == TokenType.OP || otherMatchType == TokenType.FUNCTION)) break;
 
-                    int otherPrecdence = precedenceMap.get(source.substring(otherMatch.getFrom(), otherMatch.getTo()));
-                    if(otherPrecdence < precedence ||
-                            (associativity == OperatorAssociativity.RIGHT && otherPrecdence == precedence)) {
+                    if(otherMatchType == TokenType.OP){
+                        int otherPrecedence = precedenceMap.get(source.substring(otherMatch.getFrom(), otherMatch.getTo()));
+                        if(otherPrecedence < precedence ||
+                                (associativity == OperatorAssociativity.RIGHT && otherPrecedence == precedence)) {
                             break;
                         }
+                    }
                     output.add(tokenStack.pop());
                 }
                 tokenStack.push(match);
@@ -134,7 +138,7 @@ public class TreeBuilder {
      * @param matches the list of tokens from the source string.
      * @return the construct tree expression.
      */
-    public TreeNode fromStringRecursive(String source, ArrayList<Match<TokenType>> matches){
+    public TreeNode fromStringRecursive(String source, List<Match<TokenType>> matches){
         if(matches.size() == 0) return null;
         Match<TokenType> match = matches.remove(0);
         TokenType matchType = match.getType();
@@ -151,7 +155,7 @@ public class TreeBuilder {
             while(!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END){
                 TreeNode argument = fromStringRecursive(source, matches);
                 if(argument == null) return null;
-                node.addChild(argument);
+                node.prependChild(argument);
             }
             if(matches.isEmpty()) return null;
             matches.remove(0);
@@ -166,8 +170,9 @@ public class TreeBuilder {
      * @return the resulting tree.
      */
     public TreeNode fromString(String string){
-        ArrayList<Match<TokenType>> matches = tokenize(string);
+        List<Match<TokenType>> matches = tokenize(string);
         if(matches == null) return null;
+        matches.removeIf(m -> m.getType() == TokenType.WHITESPACE);
         matches = intoPostfix(string, matches);
         if(matches == null) return null;
 

src/org/nwapw/abacus/window/HistoryTableModel.java

@@ -6,6 +6,7 @@ import javax.swing.event.TableModelListener;
 import javax.swing.table.AbstractTableModel;
 import javax.swing.table.TableModel;
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * A table model to store data about the history of inputs
@@ -57,7 +58,7 @@ public class HistoryTableModel extends AbstractTableModel {
     /**
      * The list of entries.
      */
-    ArrayList<HistoryEntry> entries;
+    List<HistoryEntry> entries;
 
     /**
      * Creates a new empty history table model