Format code.

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

@@ -57,7 +57,7 @@ public class Abacus {
     /**
      * Creates a new instance of the Abacus calculator.
      */
-    public Abacus(){
+    public Abacus() {
         pluginManager = new PluginManager();
         numberReducer = new NumberReducer(this);
         configuration = new ConfigurationObject(CONFIG_FILE);
@@ -78,8 +78,19 @@ public class Abacus {
         pluginManager.load();
     }
 
+    public static void main(String[] args) {
+        try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (ClassNotFoundException | InstantiationException | UnsupportedLookAndFeelException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+
+        new Window(new Abacus()).setVisible(true);
+    }
+
     /**
      * Gets the current tree builder.
+     *
      * @return the main tree builder in this abacus instance.
      */
     public TreeBuilder getTreeBuilder() {
@@ -88,6 +99,7 @@ public class Abacus {
 
     /**
      * Gets the current plugin manager,
+     *
      * @return the plugin manager in this abacus instance.
      */
     public PluginManager getPluginManager() {
@@ -97,6 +109,7 @@ public class Abacus {
     /**
      * Get the reducer that is responsible for transforming
      * an expression into a number.
+     *
      * @return the number reducer in this abacus instance.
      */
     public NumberReducer getNumberReducer() {
@@ -105,6 +118,7 @@ public class Abacus {
 
     /**
      * Gets the configuration object associated with this instance.
+     *
      * @return the configuration object.
      */
     public ConfigurationObject getConfiguration() {
@@ -114,32 +128,35 @@ public class Abacus {
     /**
      * Parses a string into a tree structure using the main
      * tree builder.
+     *
      * @param input the input string to parse
      * @return the resulting tree, null if the tree builder or the produced tree are null.
      */
-    public TreeNode parseString(String input){
+    public TreeNode parseString(String input) {
         return treeBuilder.fromString(input);
     }
 
     /**
      * Evaluates the given tree using the main
      * number reducer.
+     *
      * @param tree the tree to reduce, must not be null.
      * @return the resulting number, or null of the reduction failed.
      */
-    public NumberInterface evaluateTree(TreeNode tree){
+    public NumberInterface evaluateTree(TreeNode tree) {
         return tree.reduce(numberReducer);
     }
 
     /**
      * Creates a number from a string.
+     *
      * @param numberString the string to create the number from.
      * @return the resulting number.
      */
-    public NumberInterface numberFromString(String numberString){
+    public NumberInterface numberFromString(String numberString) {
         Class<? extends NumberInterface> toInstantiate =
                 pluginManager.numberFor(configuration.getNumberImplementation());
-        if(toInstantiate == null) toInstantiate = DEFAULT_NUMBER;
+        if (toInstantiate == null) toInstantiate = DEFAULT_NUMBER;
 
         try {
             return toInstantiate.getConstructor(String.class).newInstance(numberString);
@@ -148,14 +165,4 @@ public class Abacus {
         }
         return null;
     }
-
-    public static void main(String[] args){
-        try {
-            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
-        } catch (ClassNotFoundException | InstantiationException | UnsupportedLookAndFeelException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-
-        new Window(new Abacus()).setVisible(true);
-    }
 }

src/main/java/org/nwapw/abacus/config/ConfigurationObject.java

@@ -23,56 +23,12 @@ public class ConfigurationObject {
      */
     private Configuration configuration;
 
-    /**
-     * Sets up the ConfigurationObject.
-     * different constructors do different things,
-     * but they all lead here.
-     * @param configuration the configuration to set up with.
-     */
-    private void setup(Configuration configuration){
-        this.configuration = configuration;
-    }
-
-    /**
-     * Creates a default configuration.
-     * @return the newly created default configuration.
-     */
-    private Configuration getDefaultConfig(){
-        configuration = new Configuration();
-        configuration.numberType = "naive";
-        return configuration;
-    }
-
-    /**
-     * Returns the implementation the user has requested to
-     * represent their numbers.
-     * @return the implementation name.
-     */
-    public String getNumberImplementation() {
-        return configuration.numberType;
-    }
-
-    /**
-     * Saves the ConfigurationObject to the given file.
-     * @param toFile the file to save ot.
-     * @return true if the save succeed, false if otherwise.
-     */
-    public boolean save(File toFile){
-        if(toFile.getParentFile() != null) toFile.getParentFile().mkdirs();
-        try {
-            TOML_WRITER.write(configuration, toFile);
-            return true;
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return false;
-    }
-
     /**
      * Creates a new configuration object with the given config.
+     *
      * @param config the config to use.
      */
-    public ConfigurationObject(Configuration config){
+    public ConfigurationObject(Configuration config) {
         setup(config);
     }
 
@@ -80,11 +36,12 @@ public class ConfigurationObject {
      * Create a configuration object by attempting to
      * load a config from the given path, using the
      * default configuration otherwise.
+     *
      * @param path the path to attempt to load.
      */
-    public ConfigurationObject(File path){
+    public ConfigurationObject(File path) {
         Configuration config;
-        if(!path.exists()) {
+        if (!path.exists()) {
             config = getDefaultConfig();
         } else {
             Toml parse = new Toml();
@@ -98,8 +55,57 @@ public class ConfigurationObject {
      * Creates a new configuration object with the
      * default configuration.
      */
-    public ConfigurationObject(){
+    public ConfigurationObject() {
         setup(getDefaultConfig());
     }
 
+    /**
+     * Sets up the ConfigurationObject.
+     * different constructors do different things,
+     * but they all lead here.
+     *
+     * @param configuration the configuration to set up with.
+     */
+    private void setup(Configuration configuration) {
+        this.configuration = configuration;
+    }
+
+    /**
+     * Creates a default configuration.
+     *
+     * @return the newly created default configuration.
+     */
+    private Configuration getDefaultConfig() {
+        configuration = new Configuration();
+        configuration.numberType = "naive";
+        return configuration;
+    }
+
+    /**
+     * Returns the implementation the user has requested to
+     * represent their numbers.
+     *
+     * @return the implementation name.
+     */
+    public String getNumberImplementation() {
+        return configuration.numberType;
+    }
+
+    /**
+     * Saves the ConfigurationObject to the given file.
+     *
+     * @param toFile the file to save ot.
+     * @return true if the save succeed, false if otherwise.
+     */
+    public boolean save(File toFile) {
+        if (toFile.getParentFile() != null) toFile.getParentFile().mkdirs();
+        try {
+            TOML_WRITER.write(configuration, toFile);
+            return true;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
 }

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

@@ -23,6 +23,7 @@ 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.
      */
@@ -31,6 +32,7 @@ public abstract class Function {
     /**
      * 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.
      */
@@ -38,11 +40,12 @@ public abstract class Function {
 
     /**
      * 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) {
+    public NumberInterface apply(NumberInterface... params) {
-        if(!matchesParams(params)) return null;
+        if (!matchesParams(params)) return null;
         return applyInternal(params);
     }
 

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

@@ -24,11 +24,12 @@ public class Operator {
 
     /**
      * Creates a new operator with the given parameters.
+     *
      * @param associativity the associativity of the operator.
      * @param precedence    the precedence of the operator.
      * @param function      the function that the operator calls.
      */
-    public Operator(OperatorAssociativity associativity, OperatorType operatorType, int precedence, Function function){
+    public Operator(OperatorAssociativity associativity, OperatorType operatorType, int precedence, Function function) {
         this.associativity = associativity;
         this.type = operatorType;
         this.precedence = precedence;
@@ -37,6 +38,7 @@ public class Operator {
 
     /**
      * Gets the operator's associativity.
+     *
      * @return the associativity.
      */
     public OperatorAssociativity getAssociativity() {
@@ -45,6 +47,7 @@ public class Operator {
 
     /**
      * Gets the operator's type.
+     *
      * @return the type.
      */
     public OperatorType getType() {
@@ -53,6 +56,7 @@ public class Operator {
 
     /**
      * Gets the operator's precedence.
+     *
      * @return the precedence.
      */
     public int getPrecedence() {
@@ -61,6 +65,7 @@ public class Operator {
 
     /**
      * Gets the operator's function.
+     *
      * @return the function.
      */
     public Function getFunction() {

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

@@ -10,15 +10,111 @@ import java.util.*;
 /**
  * A lexer that can generate tokens of a given type given a list of regular expressions
  * to operate on.
+ *
  * @param <T> the type used to identify which match belongs to which pattern.
  */
 public class Lexer<T> {
 
+    /**
+     * The registered patterns.
+     */
+    private Map<PatternEntry<T>, Pattern<T>> patterns;
+
+    /**
+     * Creates a new lexer with no registered patterns.
+     */
+    public Lexer() {
+        patterns = new HashMap<>();
+    }
+
+    /**
+     * Registers a single pattern.
+     *
+     * @param pattern the pattern regex
+     * @param id      the ID by which to identify the pattern.
+     */
+    public void register(String pattern, T id) {
+        Pattern<T> compiledPattern = new Pattern<>(pattern, id);
+        if (compiledPattern.getHead() != null) patterns.put(new PatternEntry<>(pattern, id), compiledPattern);
+    }
+
+    /**
+     * Unregisters a pattern.
+     *
+     * @param pattern the pattern to unregister
+     * @param id      the ID by which to identify the pattern.
+     */
+    public void unregister(String pattern, T id) {
+        patterns.remove(new PatternEntry<>(pattern, id));
+    }
+
+    /**
+     * Reads one token from the given string.
+     *
+     * @param from    the string to read from
+     * @param startAt the index to start at
+     * @param compare the comparator used to sort tokens by their ID.
+     * @return the best match.
+     */
+    public Match<T> lexOne(String from, int startAt, Comparator<T> compare) {
+        ArrayList<Match<T>> matches = new ArrayList<>();
+        HashSet<PatternNode<T>> currentSet = new HashSet<>();
+        HashSet<PatternNode<T>> futureSet = new HashSet<>();
+        int index = startAt;
+        for (Pattern<T> pattern : patterns.values()) {
+            pattern.getHead().addInto(currentSet);
+        }
+        while (!currentSet.isEmpty()) {
+            for (PatternNode<T> node : currentSet) {
+                if (index < from.length() && node.matches(from.charAt(index))) {
+                    node.addOutputsInto(futureSet);
+                } else if (node instanceof EndNode) {
+                    matches.add(new Match<>(from.substring(startAt, index), ((EndNode<T>) node).getPatternId()));
+                }
+            }
+
+            HashSet<PatternNode<T>> tmp = currentSet;
+            currentSet = futureSet;
+            futureSet = tmp;
+            futureSet.clear();
+
+            index++;
+        }
+        matches.sort((a, b) -> compare.compare(a.getType(), b.getType()));
+        if (compare != null) {
+            matches.sort(Comparator.comparingInt(a -> a.getContent().length()));
+        }
+        return matches.isEmpty() ? null : matches.get(matches.size() - 1);
+    }
+
+    /**
+     * Reads all tokens from a string.
+     *
+     * @param from    the string to start from.
+     * @param startAt the index to start at.
+     * @param compare the comparator used to sort matches by their IDs.
+     * @return the resulting list of matches, in order, or null on error.
+     */
+    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;
+        while (index < from.length() && (lastMatch = lexOne(from, index, compare)) != null) {
+            int length = lastMatch.getContent().length();
+            if (length == 0) return null;
+            matches.add(lastMatch);
+            index += length;
+        }
+        if (lastMatch == null) return null;
+        return matches;
+    }
+
     /**
      * An entry that represents a pattern that has been registered with the lexer.
+     *
      * @param <T> the type used to identify the pattern.
      */
-    private static class PatternEntry<T>{
+    private static class PatternEntry<T> {
         /**
          * The name of the entry.
          */
@@ -30,10 +126,11 @@ public class Lexer<T> {
 
         /**
          * Creates a new pattern entry with the given name and id.
+         *
          * @param name the name of the pattern entry.
          * @param id   the id of the pattern entry.
          */
-        public PatternEntry(String name, T id){
+        public PatternEntry(String name, T id) {
             this.name = name;
             this.id = id;
         }
@@ -51,94 +148,4 @@ public class Lexer<T> {
         }
     }
 
-    /**
-     * The registered patterns.
-     */
-    private Map<PatternEntry<T>, Pattern<T>> patterns;
-
-    /**
-     * Creates a new lexer with no registered patterns.
-     */
-    public Lexer(){
-        patterns = new HashMap<>();
-    }
-
-    /**
-     * Registers a single pattern.
-     * @param pattern the pattern regex
-     * @param id the ID by which to identify the pattern.
-     */
-    public void register(String pattern, T id){
-        Pattern<T> compiledPattern = new Pattern<>(pattern, id);
-        if(compiledPattern.getHead() != null) patterns.put(new PatternEntry<>(pattern, id), compiledPattern);
-    }
-
-    /**
-     * Unregisters a pattern.
-     * @param pattern the pattern to unregister
-     * @param id the ID by which to identify the pattern.
-     */
-    public void unregister(String pattern, T id){
-        patterns.remove(new PatternEntry<>(pattern, id));
-    }
-
-    /**
-     * Reads one token from the given string.
-     * @param from the string to read from
-     * @param startAt the index to start at
-     * @param compare the comparator used to sort tokens by their ID.
-     * @return the best match.
-     */
-    public Match<T> lexOne(String from, int startAt, Comparator<T> compare){
-        ArrayList<Match<T>> matches = new ArrayList<>();
-        HashSet<PatternNode<T>> currentSet = new HashSet<>();
-        HashSet<PatternNode<T>> futureSet = new HashSet<>();
-        int index = startAt;
-        for(Pattern<T> pattern : patterns.values()){
-            pattern.getHead().addInto(currentSet);
-        }
-        while(!currentSet.isEmpty()){
-            for(PatternNode<T> node : currentSet){
-                if(index < from.length() && node.matches(from.charAt(index))) {
-                    node.addOutputsInto(futureSet);
-                } else if(node instanceof EndNode){
-                    matches.add(new Match<>(from.substring(startAt, index), ((EndNode<T>) node).getPatternId()));
-                }
-            }
-
-            HashSet<PatternNode<T>> tmp = currentSet;
-            currentSet = futureSet;
-            futureSet = tmp;
-            futureSet.clear();
-
-            index++;
-        }
-        matches.sort((a, b) -> compare.compare(a.getType(), b.getType()));
-        if(compare != null) {
-            matches.sort(Comparator.comparingInt(a -> a.getContent().length()));
-        }
-        return matches.isEmpty() ? null : matches.get(matches.size() - 1);
-    }
-
-    /**
-     * Reads all tokens from a string.
-     * @param from the string to start from.
-     * @param startAt the index to start at.
-     * @param compare the comparator used to sort matches by their IDs.
-     * @return the resulting list of matches, in order, or null on error.
-     */
-    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;
-        while(index < from.length() && (lastMatch = lexOne(from, index, compare)) != null){
-            int length = lastMatch.getContent().length();
-            if(length == 0) return null;
-            matches.add(lastMatch);
-            index += length;
-        }
-        if(lastMatch == null) return null;
-        return matches;
-    }
-
 }

src/main/java/org/nwapw/abacus/lexing/pattern/AnyNode.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 /**
  * A pattern node that matches any character.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class AnyNode<T> extends PatternNode<T> {

src/main/java/org/nwapw/abacus/lexing/pattern/EndNode.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 /**
  * A node that represents a successful match.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class EndNode<T> extends PatternNode<T> {
@@ -13,17 +14,19 @@ public class EndNode<T> extends PatternNode<T> {
 
     /**
      * Creates a new end node with the given ID.
+     *
      * @param patternId the pattern ID.
      */
-    public EndNode(T patternId){
+    public EndNode(T patternId) {
         this.patternId = patternId;
     }
 
     /**
      * Gets the pattern ID.
+     *
      * @return the pattern ID.
      */
-    public T getPatternId(){
+    public T getPatternId() {
         return patternId;
     }
 

src/main/java/org/nwapw/abacus/lexing/pattern/LinkNode.java

@@ -1,17 +1,17 @@
 package org.nwapw.abacus.lexing.pattern;
 
-import java.util.ArrayList;
 import java.util.Collection;
 
 /**
  * A node that is used as structural glue in pattern compilation.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class LinkNode<T> extends PatternNode<T> {
 
     @Override
     public void addInto(Collection<PatternNode<T>> into) {
-        if(!into.contains(this)) {
+        if (!into.contains(this)) {
             into.add(this);
             addOutputsInto(into);
         }

src/main/java/org/nwapw/abacus/lexing/pattern/Match.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 /**
  * A match that has been generated by the lexer.
+ *
  * @param <T> the type used to represent the ID of the pattern this match belongs to.
  */
 public class Match<T> {
@@ -17,16 +18,18 @@ public class Match<T> {
 
     /**
      * Creates a new match with the given parameters.
+     *
      * @param content the content of this match.
      * @param type    the type of the match.
      */
-    public Match(String content, T type){
+    public Match(String content, T type) {
         this.content = content;
         this.type = type;
     }
 
     /**
      * Gets the content of this match.
+     *
      * @return the content.
      */
     public String getContent() {
@@ -35,6 +38,7 @@ public class Match<T> {
 
     /**
      * Gets the pattern type of the node.
+     *
      * @return the ID of the pattern that this match matched.
      */
     public T getType() {

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

@@ -8,6 +8,7 @@ import java.util.function.Function;
 
 /**
  * A pattern that can be compiled from a string and used in lexing.
+ *
  * @param <T> the type that is used to identify and sort this pattern.
  */
 public class Pattern<T> {
@@ -40,13 +41,53 @@ public class Pattern<T> {
                 put('?', Pattern.this::transformQuestion);
             }};
 
+    /**
+     * Creates / compiles a new pattern with the given id from the given string.
+     *
+     * @param from the string to compile a pattern from.
+     * @param id   the ID to use.
+     */
+    public Pattern(String from, T id) {
+        this.id = id;
+        index = 0;
+        source = from;
+
+        PatternChain<T> chain = parseSegment(false);
+        if (chain == null) {
+            head = null;
+        } else {
+            chain.append(new EndNode<>(id));
+            head = chain.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;
+    }
+
     /**
      * A regex operator function that turns the chain
      * into a one-or-more chain.
+     *
      * @param chain the chain to transform.
      * @return the modified chain.
      */
-    private PatternChain<T> transformPlus(PatternChain<T> chain){
+    private PatternChain<T> transformPlus(PatternChain<T> chain) {
         chain.tail.outputStates.add(chain.head);
         return chain;
     }
@@ -54,10 +95,11 @@ public class Pattern<T> {
     /**
      * A regex operator function that turns the chain
      * into a zero-or-more chain.
+     *
      * @param chain the chain to transform.
      * @return the modified chain.
      */
-    private PatternChain<T> transformStar(PatternChain<T> chain){
+    private PatternChain<T> transformStar(PatternChain<T> chain) {
         LinkNode<T> newTail = new LinkNode<>();
         LinkNode<T> newHead = new LinkNode<>();
         newHead.outputStates.add(chain.head);
@@ -72,10 +114,11 @@ public class Pattern<T> {
     /**
      * A regex operator function that turns the chain
      * into a zero-or-one chain.
+     *
      * @param chain the chain to transform.
      * @return the modified chain.
      */
-    private PatternChain<T> transformQuestion(PatternChain<T> chain){
+    private PatternChain<T> transformQuestion(PatternChain<T> chain) {
         LinkNode<T> newTail = new LinkNode<>();
         LinkNode<T> newHead = new LinkNode<>();
         newHead.outputStates.add(chain.head);
@@ -88,14 +131,15 @@ public class Pattern<T> {
 
     /**
      * Combines a collection of chains into one OR chain.
+     *
      * @param collection the collection of chains to combine.
      * @return the resulting OR chain.
      */
-    private PatternChain<T> combineChains(Collection<PatternChain<T>> collection){
+    private PatternChain<T> combineChains(Collection<PatternChain<T>> collection) {
         LinkNode<T> head = new LinkNode<>();
         LinkNode<T> tail = new LinkNode<>();
         PatternChain<T> newChain = new PatternChain<>(head, tail);
-        for(PatternChain<T> chain : collection){
+        for (PatternChain<T> chain : collection) {
             head.outputStates.add(chain.head);
             chain.tail.outputStates.add(tail);
         }
@@ -104,105 +148,108 @@ public class Pattern<T> {
 
     /**
      * Parses a single value from the input into a chain.
+     *
      * @return the resulting chain, or null on error.
      */
-    private PatternChain<T> parseValue(){
+    private PatternChain<T> parseValue() {
-        if(index >= source.length()) return null;
+        if (index >= source.length()) return null;
-        if(source.charAt(index) == '\\'){
+        if (source.charAt(index) == '\\') {
-            if(++index >= source.length()) return null;
+            if (++index >= source.length()) return null;
         }
         return new PatternChain<>(new ValueNode<>(source.charAt(index++)));
     }
 
     /**
      * Parses a [] range from the input into a chain.
+     *
      * @return the resulting chain, or null on error.
      */
-    private PatternChain<T> parseOr(){
+    private PatternChain<T> parseOr() {
         Stack<PatternChain<T>> orStack = new Stack<>();
         index++;
-        while(index < source.length() && source.charAt(index) != ']'){
+        while (index < source.length() && source.charAt(index) != ']') {
-            if(source.charAt(index) == '-'){
+            if (source.charAt(index) == '-') {
                 index++;
-                if(orStack.empty() || orStack.peek().tail.range() == '\0') return null;
+                if (orStack.empty() || orStack.peek().tail.range() == '\0') return null;
                 PatternChain<T> bottomRange = orStack.pop();
                 PatternChain<T> topRange = parseValue();
-                if(topRange == null || topRange.tail.range() == '\0') return null;
+                if (topRange == null || topRange.tail.range() == '\0') return null;
 
                 orStack.push(new PatternChain<>(new RangeNode<>(bottomRange.tail.range(), topRange.tail.range())));
             } else {
                 PatternChain<T> newChain = parseValue();
-                if(newChain == null) return null;
+                if (newChain == null) return null;
                 orStack.push(newChain);
             }
         }
-        if(index++ >= source.length()) return null;
+        if (index++ >= source.length()) return null;
         return (orStack.size() == 1) ? orStack.pop() : combineChains(orStack);
     }
 
     /**
      * Parses a repeatable segment from the input into a chain
+     *
      * @param isSubsegment whether the segment is a sub-expression "()", and therefore
      *                     whether to expect a closing brace.
      * @return the resulting chain, or null on error.
      */
-    private PatternChain<T> parseSegment(boolean isSubsegment){
+    private PatternChain<T> parseSegment(boolean isSubsegment) {
-        if(index >= source.length() || ((source.charAt(index) != '(') && isSubsegment)) return null;
+        if (index >= source.length() || ((source.charAt(index) != '(') && isSubsegment)) return null;
-        if(isSubsegment) index++;
+        if (isSubsegment) index++;
 
         Stack<PatternChain<T>> orChain = new Stack<>();
         PatternChain<T> fullChain = new PatternChain<>();
         PatternChain<T> currentChain = null;
-        while (index < source.length() && source.charAt(index) != ')'){
+        while (index < source.length() && source.charAt(index) != ')') {
             char currentChar = source.charAt(index);
-            if(operations.containsKey(currentChar)){
+            if (operations.containsKey(currentChar)) {
-                if(currentChain == null) return null;
+                if (currentChain == null) return null;
 
                 currentChain = operations.get(currentChar).apply(currentChain);
                 fullChain.append(currentChain);
                 currentChain = null;
                 index++;
-            } else if(currentChar == '|'){
+            } else if (currentChar == '|') {
-                if(currentChain == null) return null;
+                if (currentChain == null) return null;
 
                 fullChain.append(currentChain);
                 orChain.push(fullChain);
                 currentChain = null;
                 fullChain = new PatternChain<>();
-                if(++index >= source.length()) return null;
+                if (++index >= source.length()) return null;
-            } else if(currentChar == '('){
+            } else if (currentChar == '(') {
-                if(currentChain != null) {
+                if (currentChain != null) {
                     fullChain.append(currentChain);
                 }
 
                 currentChain = parseSegment(true);
-                if(currentChain == null) return null;
+                if (currentChain == null) return null;
-            } else if(currentChar == '['){
+            } else if (currentChar == '[') {
-                if(currentChain != null){
+                if (currentChain != null) {
                     fullChain.append(currentChain);
                 }
                 currentChain = parseOr();
-                if(currentChain == null) return null;
+                if (currentChain == null) return null;
-            } else if(currentChar == '.'){
+            } else if (currentChar == '.') {
-                if(currentChain != null){
+                if (currentChain != null) {
                     fullChain.append(currentChain);
                 }
                 currentChain = new PatternChain<>(new AnyNode<>());
                 index++;
             } else {
-                if(currentChain != null){
+                if (currentChain != null) {
                     fullChain.append(currentChain);
                 }
                 currentChain = parseValue();
-                if(currentChain == null) return null;
+                if (currentChain == null) return null;
             }
         }
 
-        if(!(!isSubsegment || (index < source.length() && source.charAt(index) == ')'))) return null;
+        if (!(!isSubsegment || (index < source.length() && source.charAt(index) == ')'))) return null;
-        if(isSubsegment) index++;
+        if (isSubsegment) index++;
 
-        if(currentChain != null) fullChain.append(currentChain);
+        if (currentChain != null) fullChain.append(currentChain);
-        if(!orChain.empty()){
+        if (!orChain.empty()) {
             orChain.push(fullChain);
             fullChain = combineChains(orChain);
         }
@@ -210,48 +257,12 @@ public class Pattern<T> {
         return fullChain;
     }
 
-    /**
-     * Creates / compiles a new pattern with the given id from the given string.
-     * @param from the string to compile a pattern from.
-     * @param id the ID to use.
-     */
-    public Pattern(String from, T id){
-        this.id = id;
-        index = 0;
-        source = from;
-
-        PatternChain<T> chain = parseSegment(false);
-        if(chain == null) {
-            head = null;
-        } else {
-            chain.append(new EndNode<>(id));
-            head = chain.head;
-        }
-    }
-
     /**
      * Gets the head PatternNode, for use in matching
+     *
      * @return the pattern node.
      */
     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/main/java/org/nwapw/abacus/lexing/pattern/PatternChain.java

@@ -3,6 +3,7 @@ package org.nwapw.abacus.lexing.pattern;
 /**
  * A chain of nodes that can be treated as a single unit.
  * Used during pattern compilation.
+ *
  * @param <T> the type used to identify which pattern has been matched.
  */
 public class PatternChain<T> {
@@ -18,26 +19,28 @@ public class PatternChain<T> {
 
     /**
      * Creates a new chain with the given start and end.
+     *
      * @param head the start of the chain.
      * @param tail the end of the chain.
      */
-    public PatternChain(PatternNode<T> head, PatternNode<T> tail){
+    public PatternChain(PatternNode<T> head, PatternNode<T> tail) {
         this.head = head;
         this.tail = tail;
     }
 
     /**
      * Creates a chain that starts and ends with the same node.
+     *
      * @param node the node to use.
      */
-    public PatternChain(PatternNode<T> node){
+    public PatternChain(PatternNode<T> node) {
         this(node, node);
     }
 
     /**
      * Creates an empty chain.
      */
-    public PatternChain(){
+    public PatternChain() {
         this(null);
     }
 
@@ -45,10 +48,11 @@ public class PatternChain<T> {
      * Appends the other chain to this one. This modifies
      * the nodes, as well.
      * If this chain is empty, it is set to the other.
+     *
      * @param other the other chain to append.
      */
-    public void append(PatternChain<T> other){
+    public void append(PatternChain<T> other) {
-        if(other.head == null || tail == null) {
+        if (other.head == null || tail == null) {
             this.head = other.head;
             this.tail = other.tail;
         } else {
@@ -61,10 +65,11 @@ public class PatternChain<T> {
      * Appends a single node to this chain. This modifies
      * the nodes, as well.
      * If this chain is empty, it is set to the node.
+     *
      * @param node the node to append to this chain.
      */
-    public void append(PatternNode<T> node){
+    public void append(PatternNode<T> node) {
-        if(tail == null){
+        if (tail == null) {
             head = tail = node;
         } else {
             tail.outputStates.add(node);

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

@@ -1,6 +1,5 @@
 package org.nwapw.abacus.lexing.pattern;
 
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
@@ -9,6 +8,7 @@ import java.util.Set;
  * A base class for a pattern node. Provides all functions
  * necessary for matching, and is constructed by a Pattern instance
  * from a string.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class PatternNode<T> {
@@ -22,42 +22,46 @@ public class PatternNode<T> {
     /**
      * Creates a new pattern node.
      */
-    public PatternNode(){
+    public PatternNode() {
         outputStates = new HashSet<>();
     }
 
     /**
      * Determines whether the current input character can
      * be matched by this node.
+     *
      * @param other the character being matched.
      * @return true if the character can be matched, false otherwise.
      */
-    public boolean matches(char other){
+    public boolean matches(char other) {
         return false;
     }
 
     /**
      * If this node can be used as part of a range, returns that value.
+     *
      * @return a NULL terminator if this character cannot be converted
      * into a range bound, or the appropriate range bound if it can.
      */
-    public char range(){
+    public char range() {
         return '\0';
     }
 
     /**
      * Adds this node in a collection of other nodes.
+     *
      * @param into the collection to add into.
      */
-    public void addInto(Collection<PatternNode<T>> into){
+    public void addInto(Collection<PatternNode<T>> into) {
         into.add(this);
     }
 
     /**
      * Adds the node's children into a collection of other nodes.
+     *
      * @param into the collection to add into.
      */
-    public void addOutputsInto(Collection<PatternNode<T>> into){
+    public void addOutputsInto(Collection<PatternNode<T>> into) {
         outputStates.forEach(e -> e.addInto(into));
     }
 

src/main/java/org/nwapw/abacus/lexing/pattern/RangeNode.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 /**
  * A node that matches a range of characters.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class RangeNode<T> extends PatternNode<T> {
@@ -17,10 +18,11 @@ public class RangeNode<T> extends PatternNode<T> {
 
     /**
      * Creates a new range node from the given range.
+     *
      * @param from the bottom bound of the range.
      * @param to   the top bound of hte range.
      */
-    public RangeNode(char from, char to){
+    public RangeNode(char from, char to) {
         this.from = from;
         this.to = to;
     }

src/main/java/org/nwapw/abacus/lexing/pattern/ValueNode.java

@@ -2,6 +2,7 @@ package org.nwapw.abacus.lexing.pattern;
 
 /**
  * A node that matches a single value.
+ *
  * @param <T> the type that's used to tell which pattern this node belongs to.
  */
 public class ValueNode<T> extends PatternNode<T> {
@@ -13,9 +14,10 @@ public class ValueNode<T> extends PatternNode<T> {
 
     /**
      * Creates a new node that matches the given character.
+     *
      * @param value
      */
-    public ValueNode(char value){
+    public ValueNode(char value) {
         this.value = value;
     }
 

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

@@ -5,26 +5,6 @@ package org.nwapw.abacus.number;
  */
 public class NaiveNumber implements NumberInterface {
 
-    /**
-     * The value of this number.
-     */
-    private double value;
-
-    /**
-     * Creates a new NaiveNumber with the given string.
-     * @param value the value, which will be parsed as a double.
-     */
-    public NaiveNumber(String value) {
-        this(Double.parseDouble(value));
-    }
-    /**
-     * Creates a new NaiveNumber with the given value.
-     * @param value the value to use.
-     */
-    public NaiveNumber(double value) {
-        this.value = value;
-    }
-
     /**
      * The number zero.
      */
@@ -33,6 +13,27 @@ public class NaiveNumber implements NumberInterface {
      * The number one.
      */
     public static final NaiveNumber ONE = new NaiveNumber(1);
+    /**
+     * The value of this number.
+     */
+    private double value;
+
+    /**
+     * Creates a new NaiveNumber with the given string.
+     *
+     * @param value the value, which will be parsed as a double.
+     */
+    public NaiveNumber(String value) {
+        this(Double.parseDouble(value));
+    }
+    /**
+     * Creates a new NaiveNumber with the given value.
+     *
+     * @param value the value to use.
+     */
+    public NaiveNumber(double value) {
+        this.value = value;
+    }
 
     @Override
     public int getMaxPrecision() {
@@ -41,22 +42,22 @@ public class NaiveNumber implements NumberInterface {
 
     @Override
     public NumberInterface multiply(NumberInterface multiplier) {
-        return new NaiveNumber(value * ((NaiveNumber)multiplier).value);
+        return new NaiveNumber(value * ((NaiveNumber) multiplier).value);
     }
 
     @Override
     public NumberInterface divide(NumberInterface divisor) {
-        return new NaiveNumber(value / ((NaiveNumber)divisor).value);
+        return new NaiveNumber(value / ((NaiveNumber) divisor).value);
     }
 
     @Override
     public NumberInterface add(NumberInterface summand) {
-        return new NaiveNumber(value + ((NaiveNumber)summand).value);
+        return new NaiveNumber(value + ((NaiveNumber) summand).value);
     }
 
     @Override
     public NumberInterface subtract(NumberInterface subtrahend) {
-        return new NaiveNumber(value - ((NaiveNumber)subtrahend).value);
+        return new NaiveNumber(value - ((NaiveNumber) subtrahend).value);
     }
 
     @Override
@@ -66,16 +67,16 @@ public class NaiveNumber implements NumberInterface {
 
     @Override
     public NumberInterface intPow(int exponent) {
-        if(exponent == 0){
+        if (exponent == 0) {
             return NaiveNumber.ONE;
         }
         boolean takeReciprocal = exponent < 0;
         exponent = Math.abs(exponent);
         NumberInterface power = this;
-        for(int currentExponent = 1; currentExponent < exponent; currentExponent++){
+        for (int currentExponent = 1; currentExponent < exponent; currentExponent++) {
             power = power.multiply(this);
         }
-        if(takeReciprocal){
+        if (takeReciprocal) {
             power = NaiveNumber.ONE.divide(power);
         }
         return power;
@@ -94,14 +95,14 @@ public class NaiveNumber implements NumberInterface {
 
     @Override
     public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
-        if(toClass == this.getClass()) return this;
+        if (toClass == this.getClass()) return this;
-        else if(toClass == PreciseNumber.class){
+        else if (toClass == PreciseNumber.class) {
             return new PreciseNumber(Double.toString(value));
         }
         return null;
     }
 
-    public String toString(){
+    public String toString() {
         double shiftBy = Math.pow(10, 10);
         return Double.toString(Math.round(value * shiftBy) / shiftBy);
     }

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

@@ -7,6 +7,7 @@ public interface NumberInterface {
 
     /**
      * The maximum precision to which this number operates.
+     *
      * @return the precision.
      */
     int getMaxPrecision();
@@ -14,27 +15,34 @@ public interface NumberInterface {
     /**
      * Multiplies this number by another, returning
      * a new number instance.
+     *
      * @param multiplier the multiplier
      * @return the result of the multiplication.
      */
     NumberInterface multiply(NumberInterface multiplier);
+
     /**
      * Divides this number by another, returning
      * a new number instance.
+     *
      * @param divisor the divisor
      * @return the result of the division.
      */
     NumberInterface divide(NumberInterface divisor);
+
     /**
      * Adds this number to another, returning
      * a new number instance.
+     *
      * @param summand the summand
      * @return the result of the summation.
      */
     NumberInterface add(NumberInterface summand);
+
     /**
      * Subtracts another number from this number,
      * a new number instance.
+     *
      * @param subtrahend the subtrahend.
      * @return the result of the subtraction.
      */
@@ -43,12 +51,14 @@ public interface NumberInterface {
     /**
      * Returns a new instance of this number with
      * the sign flipped.
+     *
      * @return the new instance.
      */
     NumberInterface negate();
 
     /**
      * Raises this number to an integer power.
+     *
      * @param exponent the exponent to which to take the number.
      * @return the resulting value.
      */
@@ -56,6 +66,7 @@ public interface NumberInterface {
 
     /**
      * Compares this number to another.
+     *
      * @param number the number to compare to.
      * @return same as Integer.compare();
      */
@@ -63,12 +74,14 @@ public interface NumberInterface {
 
     /**
      * Same as Math.signum().
+     *
      * @return 1 if this number is positive, -1 if this number is negative, 0 if this number is 0.
      */
     int signum();
 
     /**
      * Promotes this class to another number class.
+     *
      * @param toClass the class to promote to.
      * @return the resulting new instance.
      */

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

@@ -3,7 +3,7 @@ package org.nwapw.abacus.number;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 
-public class PreciseNumber implements NumberInterface{
+public class PreciseNumber implements NumberInterface {
 
     /**
      * The number one.
@@ -25,18 +25,20 @@ public class PreciseNumber implements NumberInterface{
 
     /**
      * 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){
+    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){
+    public PreciseNumber(BigDecimal value) {
         this.value = value;
     }
 
@@ -67,16 +69,16 @@ public class PreciseNumber implements NumberInterface{
 
     @Override
     public NumberInterface intPow(int exponent) {
-        if(exponent == 0){
+        if (exponent == 0) {
             return PreciseNumber.ONE;
         }
         boolean takeReciprocal = exponent < 0;
         exponent = Math.abs(exponent);
         NumberInterface power = this;
-        for(int currentExponent = 1; currentExponent < exponent; currentExponent++){
+        for (int currentExponent = 1; currentExponent < exponent; currentExponent++) {
             power = power.multiply(this);
         }
-        if(takeReciprocal){
+        if (takeReciprocal) {
             power = PreciseNumber.ONE.divide(power);
         }
         return power;
@@ -93,13 +95,13 @@ public class PreciseNumber implements NumberInterface{
     }
 
     @Override
-    public NumberInterface negate(){
+    public NumberInterface negate() {
         return new PreciseNumber(value.negate());
     }
 
     @Override
     public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
-        if(toClass == this.getClass()){
+        if (toClass == this.getClass()) {
             return this;
         }
         return null;

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

@@ -29,7 +29,7 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
     /**
      * Creates a new lexer tokenizer.
      */
-    public LexerTokenizer(){
+    public LexerTokenizer() {
         lexer = new Lexer<TokenType>() {{
             register(" ", TokenType.WHITESPACE);
             register(",", TokenType.COMMA);
@@ -46,20 +46,20 @@ public class LexerTokenizer implements Tokenizer<Match<TokenType>>, PluginListen
 
     @Override
     public void onLoad(PluginManager manager) {
-        for(String operator : manager.getAllOperators()){
+        for (String operator : manager.getAllOperators()) {
             lexer.register(Pattern.sanitize(operator), TokenType.OP);
         }
-        for(String function : manager.getAllFunctions()){
+        for (String function : manager.getAllFunctions()) {
             lexer.register(Pattern.sanitize(function), TokenType.FUNCTION);
         }
     }
 
     @Override
     public void onUnload(PluginManager manager) {
-        for(String operator : manager.getAllOperators()){
+        for (String operator : manager.getAllOperators()) {
             lexer.unregister(Pattern.sanitize(operator), TokenType.OP);
         }
-        for(String function : manager.getAllFunctions()){
+        for (String function : manager.getAllFunctions()) {
             lexer.unregister(Pattern.sanitize(function), TokenType.FUNCTION);
         }
     }

src/main/java/org/nwapw/abacus/parsing/Parser.java

@@ -7,12 +7,14 @@ import java.util.List;
 /**
  * An itnerface that provides the ability to convert a list of tokens
  * into a parse tree.
+ *
  * @param <T> the type of tokens accepted by this parser.
  */
 public interface Parser<T> {
 
     /**
      * Constructs a tree out of the given tokens.
+     *
      * @param tokens the tokens to construct a tree from.
      * @return the constructed tree, or null on error.
      */

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

@@ -36,9 +36,10 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
 
     /**
      * Creates a new Shunting Yard parser with the given Abacus instance.
+     *
      * @param abacus the abacus instance.
      */
-    public ShuntingYardParser(Abacus abacus){
+    public ShuntingYardParser(Abacus abacus) {
         this.abacus = abacus;
         precedenceMap = new HashMap<>();
         associativityMap = new HashMap<>();
@@ -47,39 +48,40 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
 
     /**
      * Rearranges tokens into a postfix list, using Shunting Yard.
+     *
      * @param from the tokens to be rearranged.
      * @return the resulting list of rearranged tokens.
      */
-    public List<Match<TokenType>> intoPostfix(List<Match<TokenType>> from){
+    public List<Match<TokenType>> intoPostfix(List<Match<TokenType>> from) {
         ArrayList<Match<TokenType>> output = new ArrayList<>();
         Stack<Match<TokenType>> tokenStack = new Stack<>();
-        while(!from.isEmpty()){
+        while (!from.isEmpty()) {
             Match<TokenType> match = from.remove(0);
             TokenType matchType = match.getType();
-            if(matchType == TokenType.NUM) {
+            if (matchType == TokenType.NUM) {
                 output.add(match);
-            } else if(matchType == TokenType.FUNCTION) {
+            } else if (matchType == TokenType.FUNCTION) {
-                output.add(new Match<>("" , TokenType.INTERNAL_FUNCTION_END));
+                output.add(new Match<>("", TokenType.INTERNAL_FUNCTION_END));
                 tokenStack.push(match);
-            } else if(matchType == TokenType.OP){
+            } else if (matchType == TokenType.OP) {
                 String tokenString = match.getContent();
                 OperatorType type = typeMap.get(tokenString);
                 int precedence = precedenceMap.get(tokenString);
                 OperatorAssociativity associativity = associativityMap.get(tokenString);
 
-                if(type == OperatorType.UNARY_POSTFIX){
+                if (type == OperatorType.UNARY_POSTFIX) {
                     output.add(match);
                     continue;
                 }
 
-                while(!tokenStack.empty()) {
+                while (!tokenStack.empty()) {
                     Match<TokenType> otherMatch = tokenStack.peek();
                     TokenType otherMatchType = otherMatch.getType();
-                    if(!(otherMatchType == TokenType.OP || otherMatchType == TokenType.FUNCTION)) break;
+                    if (!(otherMatchType == TokenType.OP || otherMatchType == TokenType.FUNCTION)) break;
 
-                    if(otherMatchType == TokenType.OP){
+                    if (otherMatchType == TokenType.OP) {
                         int otherPrecedence = precedenceMap.get(match.getContent());
-                        if(otherPrecedence < precedence ||
+                        if (otherPrecedence < precedence ||
                                 (associativity == OperatorAssociativity.RIGHT && otherPrecedence == precedence)) {
                             break;
                         }
@@ -87,22 +89,22 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
                     output.add(tokenStack.pop());
                 }
                 tokenStack.push(match);
-            } else if(matchType == TokenType.OPEN_PARENTH){
+            } else if (matchType == TokenType.OPEN_PARENTH) {
                 tokenStack.push(match);
-            } else if(matchType == TokenType.CLOSE_PARENTH || matchType == TokenType.COMMA){
+            } else if (matchType == TokenType.CLOSE_PARENTH || matchType == TokenType.COMMA) {
-                while(!tokenStack.empty() && tokenStack.peek().getType() != TokenType.OPEN_PARENTH){
+                while (!tokenStack.empty() && tokenStack.peek().getType() != TokenType.OPEN_PARENTH) {
                     output.add(tokenStack.pop());
                 }
-                if(tokenStack.empty()) return null;
+                if (tokenStack.empty()) return null;
-                if(matchType == TokenType.CLOSE_PARENTH){
+                if (matchType == TokenType.CLOSE_PARENTH) {
                     tokenStack.pop();
                 }
             }
         }
-        while(!tokenStack.empty()){
+        while (!tokenStack.empty()) {
             Match<TokenType> match = tokenStack.peek();
             TokenType matchType = match.getType();
-            if(!(matchType == TokenType.OP || matchType == TokenType.FUNCTION)) return null;
+            if (!(matchType == TokenType.OP || matchType == TokenType.FUNCTION)) return null;
             output.add(tokenStack.pop());
         }
         return output;
@@ -110,37 +112,38 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
 
     /**
      * Constructs a tree recursively from a list of tokens.
+     *
      * @param matches the list of tokens from the source string.
      * @return the construct tree expression.
      */
-    public TreeNode constructRecursive(List<Match<TokenType>> matches){
+    public TreeNode constructRecursive(List<Match<TokenType>> matches) {
-        if(matches.size() == 0) return null;
+        if (matches.size() == 0) return null;
         Match<TokenType> match = matches.remove(0);
         TokenType matchType = match.getType();
-        if(matchType == TokenType.OP){
+        if (matchType == TokenType.OP) {
             String operator = match.getContent();
             OperatorType type = typeMap.get(operator);
-            if(type == OperatorType.BINARY_INFIX){
+            if (type == OperatorType.BINARY_INFIX) {
                 TreeNode right = constructRecursive(matches);
                 TreeNode left = constructRecursive(matches);
-                if(left == null || right == null) return null;
+                if (left == null || right == null) return null;
                 else return new BinaryInfixNode(operator, left, right);
             } else {
                 TreeNode applyTo = constructRecursive(matches);
-                if(applyTo == null) return null;
+                if (applyTo == null) return null;
                 else return new UnaryPrefixNode(operator, applyTo);
             }
-        } else if(matchType == TokenType.NUM){
+        } else if (matchType == TokenType.NUM) {
             return new NumberNode(abacus.numberFromString(match.getContent()));
-        } else if(matchType == TokenType.FUNCTION){
+        } else if (matchType == TokenType.FUNCTION) {
             String functionName = match.getContent();
             FunctionNode node = new FunctionNode(functionName);
-            while(!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END){
+            while (!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END) {
                 TreeNode argument = constructRecursive(matches);
-                if(argument == null) return null;
+                if (argument == null) return null;
                 node.prependChild(argument);
             }
-            if(matches.isEmpty()) return null;
+            if (matches.isEmpty()) return null;
             matches.remove(0);
             return node;
         }
@@ -156,7 +159,7 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
 
     @Override
     public void onLoad(PluginManager manager) {
-        for(String operator : manager.getAllOperators()){
+        for (String operator : manager.getAllOperators()) {
             Operator operatorInstance = manager.operatorFor(operator);
             precedenceMap.put(operator, operatorInstance.getPrecedence());
             associativityMap.put(operator, operatorInstance.getAssociativity());

src/main/java/org/nwapw/abacus/parsing/Tokenizer.java

@@ -4,12 +4,14 @@ import java.util.List;
 
 /**
  * Interface that provides the ability to convert a string into a list of tokens.
+ *
  * @param <T> the type of the tokens produced.
  */
 public interface Tokenizer<T> {
 
     /**
      * Converts a string into tokens.
+     *
      * @param string the string to convert.
      * @return the list of tokens, or null on error.
      */

src/main/java/org/nwapw/abacus/parsing/TreeBuilder.java

@@ -10,6 +10,7 @@ import java.util.List;
  * working with any parameters at all, and the generics
  * in this class are used only to ensure the tokenizer and parser
  * are of the same type.
+ *
  * @param <T> the type of tokens created by the tokenizer and used by the parser.
  */
 public class TreeBuilder<T> {
@@ -25,22 +26,24 @@ public class TreeBuilder<T> {
 
     /**
      * Create a new Tree Builder with the given tokenizer and parser
+     *
      * @param tokenizer the tokenizer to turn strings into tokens
      * @param parser    the parser to turn tokens into a tree
      */
-    public TreeBuilder(Tokenizer<T> tokenizer, Parser<T> parser){
+    public TreeBuilder(Tokenizer<T> tokenizer, Parser<T> parser) {
         this.tokenizer = tokenizer;
         this.parser = parser;
     }
 
     /**
      * Parse the given string into a tree.
+     *
      * @param input the string to parse into a tree.
      * @return the resulting tree.
      */
-    public TreeNode fromString(String input){
+    public TreeNode fromString(String input) {
         List<T> tokens = tokenizer.tokenizeString(input);
-        if(tokens == null) return null;
+        if (tokens == null) return null;
         return parser.constructTree(tokens);
     }
 

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

@@ -20,6 +20,7 @@ public class ClassFinder {
 
     /**
      * Loads all the plugin classes from the given plugin folder.
+     *
      * @param filePath the path for the plugin folder.
      * @return the list of all loaded classes.
      * @throws IOException            thrown if an error occurred scanning the plugin folder.
@@ -31,6 +32,7 @@ public class ClassFinder {
 
     /**
      * Loads all the plugin classes from the given plugin folder.
+     *
      * @param pluginFolderPath the folder in which to look for plugins.
      * @return the list of all loaded classes.
      * @throws IOException            thrown if an error occurred scanning the plugin folder.
@@ -38,12 +40,12 @@ public class ClassFinder {
      */
     public static List<Class<?>> loadJars(File pluginFolderPath) throws IOException, ClassNotFoundException {
         ArrayList<Class<?>> toReturn = new ArrayList<>();
-        if(!pluginFolderPath.exists()) return toReturn;
+        if (!pluginFolderPath.exists()) return toReturn;
         ArrayList<File> files = Files.walk(pluginFolderPath.toPath())
                 .map(Path::toFile)
                 .filter(f -> f.getName().endsWith(".jar"))
                 .collect(Collectors.toCollection(ArrayList::new));
-        for (File file : files){
+        for (File file : files) {
             toReturn.addAll(loadJar(file));
         }
         return toReturn;
@@ -51,6 +53,7 @@ public class ClassFinder {
 
     /**
      * Loads the classes from a single path, given by the file.
+     *
      * @param jarLocation the location of the jar to load.
      * @return the list of loaded classes loaded from the jar.
      * @throws IOException            thrown if there was an error reading the file

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

@@ -39,10 +39,12 @@ public abstract class Plugin {
      */
     private boolean enabled;
 
-    private Plugin(){ }
+    private Plugin() {
+    }
 
     /**
      * Creates a new plugin with the given PluginManager.
+     *
      * @param manager the manager controlling this plugin.
      */
     public Plugin(PluginManager manager) {
@@ -55,30 +57,34 @@ public abstract class Plugin {
 
     /**
      * Gets the list of functions provided by this plugin.
+     *
      * @return the list of registered functions.
      */
-    public final Set<String> providedFunctions(){
+    public final Set<String> providedFunctions() {
         return functions.keySet();
     }
 
     /**
      * Gets the list of functions provided by this plugin.
+     *
      * @return the list of registered functions.
      */
-    public final Set<String> providedOperators(){
+    public final Set<String> providedOperators() {
         return operators.keySet();
     }
 
     /**
      * Gets the list of all numbers provided by this plugin.
+     *
      * @return the list of registered numbers.
      */
-    public final Set<String> providedNumbers(){
+    public final Set<String> providedNumbers() {
         return numbers.keySet();
     }
 
     /**
      * Gets a function under the given function name.
+     *
      * @param functionName the name of the function to get
      * @return the function, or null if this plugin doesn't provide it.
      */
@@ -88,6 +94,7 @@ public abstract class Plugin {
 
     /**
      * Gets an operator under the given operator name.
+     *
      * @param operatorName the name of the operator to get.
      * @return the operator, or null if this plugin doesn't provide it.
      */
@@ -97,10 +104,11 @@ public abstract class Plugin {
 
     /**
      * Gets the class under the given name.
+     *
      * @param numberName the name of the class.
      * @return the class, or null if the plugin doesn't provide it.
      */
-    public final Class<? extends NumberInterface> getNumber(String numberName){
+    public final Class<? extends NumberInterface> getNumber(String numberName) {
         return numbers.get(numberName);
     }
 
@@ -108,8 +116,8 @@ public abstract class Plugin {
      * Enables the function, loading the necessary instances
      * of functions.
      */
-    public final void enable(){
+    public final void enable() {
-        if(enabled) return;
+        if (enabled) return;
         onEnable();
         enabled = true;
     }
@@ -118,8 +126,8 @@ public abstract class Plugin {
      * Disables the plugin, clearing loaded data store by default
      * and calling its disable() method.
      */
-    public final void disable(){
+    public final void disable() {
-        if(!enabled) return;
+        if (!enabled) return;
         onDisable();
         functions.clear();
         operators.clear();
@@ -129,6 +137,7 @@ public abstract class Plugin {
     /**
      * To be used in load(). Registers a 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 function implementation.
      */
@@ -140,6 +149,7 @@ public abstract class Plugin {
      * To be used in load(). Registers an operator abstract class
      * with the plugin internally, which makes it accessible to
      * the plugin manager.
+     *
      * @param name     the name of the operator.
      * @param operator the operator to register.
      */
@@ -152,10 +162,11 @@ public abstract class Plugin {
      * with the plugin internally, which makes it possible
      * for the user to select it as an "implementation" for the
      * number that they would like to use.
+     *
      * @param name       the name to register it under.
      * @param toRegister the class to register.
      */
-    protected final void registerNumber(String name, Class<? extends NumberInterface> toRegister){
+    protected final void registerNumber(String name, Class<? extends NumberInterface> toRegister) {
         numbers.put(name, toRegister);
     }
 
@@ -163,6 +174,7 @@ public abstract class Plugin {
      * 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 function, or null if none was found for that name.
      */
@@ -174,6 +186,7 @@ public abstract class Plugin {
      * Searches the PluginManager for the given 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 operator, or null if none was found for that name.
      */

src/main/java/org/nwapw/abacus/plugin/PluginListener.java

@@ -7,12 +7,14 @@ public interface PluginListener {
 
     /**
      * Called when the PluginManager loads plugins.
+     *
      * @param manager the manager that fired the event.
      */
     public void onLoad(PluginManager manager);
 
     /**
      * Called when the PluginManager unloads all its plugins.
+     *
      * @param manager the manager that fired the event.
      */
     public void onUnload(PluginManager manager);

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

@@ -56,7 +56,7 @@ public class PluginManager {
     /**
      * Creates a new plugin manager.
      */
-    public PluginManager(){
+    public PluginManager() {
         loadedPluginClasses = new HashSet<>();
         plugins = new HashSet<>();
         cachedFunctions = new HashMap<>();
@@ -73,6 +73,7 @@ public class PluginManager {
      * list of items of the type using the setFunction and getting the value
      * of it is available via getFunction. If the value is contained
      * in the cache, it returns the cached value instead.
+     *
      * @param plugins     the plugin list to search.
      * @param cache       the cache to use
      * @param setFunction the function to retrieve a set of available T's from the plugin
@@ -84,12 +85,12 @@ public class PluginManager {
     private static <T> T searchCached(Collection<Plugin> plugins, Map<String, T> cache,
                                       java.util.function.Function<Plugin, Set<String>> setFunction,
                                       java.util.function.BiFunction<Plugin, String, T> getFunction,
-                                      String name){
+                                      String name) {
-        if(cache.containsKey(name)) return cache.get(name);
+        if (cache.containsKey(name)) return cache.get(name);
 
         T loadedValue = null;
-        for(Plugin plugin : plugins){
+        for (Plugin plugin : plugins) {
-            if(setFunction.apply(plugin).contains(name)){
+            if (setFunction.apply(plugin).contains(name)) {
                 loadedValue = getFunction.apply(plugin, name);
                 break;
             }
@@ -98,39 +99,44 @@ public class PluginManager {
         cache.put(name, loadedValue);
         return loadedValue;
     }
+
     /**
      * Gets a function under the given name.
+     *
      * @param name the name of the function
      * @return the function under the given name.
      */
-    public Function functionFor(String name){
+    public Function functionFor(String name) {
         return searchCached(plugins, cachedFunctions, Plugin::providedFunctions, Plugin::getFunction, name);
     }
 
     /**
      * Gets an operator under the given name.
+     *
      * @param name the name of the operator.
      * @return the operator under the given name.
      */
-    public Operator operatorFor(String name){
+    public Operator operatorFor(String name) {
         return searchCached(plugins, cachedOperators, Plugin::providedOperators, Plugin::getOperator, name);
     }
 
     /**
      * Gets a numer implementation under the given name.
+     *
      * @param name the name of the implementation.
      * @return the implementation class
      */
-    public Class<? extends NumberInterface> numberFor(String name){
+    public Class<? extends NumberInterface> numberFor(String name) {
         return searchCached(plugins, cachedNumbers, Plugin::providedNumbers, Plugin::getNumber, name);
     }
 
     /**
      * Adds an instance of Plugin that already has been instantiated.
+     *
      * @param plugin the plugin to add.
      */
-    public void addInstantiated(Plugin plugin){
+    public void addInstantiated(Plugin plugin) {
-        if(loadedPluginClasses.contains(plugin.getClass())) return;
+        if (loadedPluginClasses.contains(plugin.getClass())) return;
         plugins.add(plugin);
         loadedPluginClasses.add(plugin.getClass());
     }
@@ -138,10 +144,11 @@ public class PluginManager {
     /**
      * Instantiates a class of plugin, and adds it to this
      * plugin manager.
+     *
      * @param newClass the new class to instantiate.
      */
-    public void addClass(Class<?> newClass){
+    public void addClass(Class<?> newClass) {
-        if(!Plugin.class.isAssignableFrom(newClass) || newClass == Plugin.class) return;
+        if (!Plugin.class.isAssignableFrom(newClass) || newClass == Plugin.class) return;
         try {
             addInstantiated((Plugin) newClass.getConstructor(PluginManager.class).newInstance(this));
         } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
@@ -152,9 +159,9 @@ public class PluginManager {
     /**
      * Loads all the plugins in the PluginManager.
      */
-    public void load(){
+    public void load() {
-        for(Plugin plugin : plugins) plugin.enable();
+        for (Plugin plugin : plugins) plugin.enable();
-        for(Plugin plugin : plugins){
+        for (Plugin plugin : plugins) {
             allFunctions.addAll(plugin.providedFunctions());
             allOperators.addAll(plugin.providedOperators());
             allNumbers.addAll(plugin.providedNumbers());
@@ -165,8 +172,8 @@ public class PluginManager {
     /**
      * Unloads all the plugins in the PluginManager.
      */
-    public void unload(){
+    public void unload() {
-        for(Plugin plugin : plugins) plugin.disable();
+        for (Plugin plugin : plugins) plugin.disable();
         allFunctions.clear();
         allOperators.clear();
         allNumbers.clear();
@@ -176,13 +183,14 @@ public class PluginManager {
     /**
      * Reloads all the plugins in the PluginManager.
      */
-    public void reload(){
+    public void reload() {
         unload();
         reload();
     }
 
     /**
      * Gets all the functions loaded by the Plugin Manager.
+     *
      * @return the set of all functions that were loaded.
      */
     public Set<String> getAllFunctions() {
@@ -191,6 +199,7 @@ public class PluginManager {
 
     /**
      * Gets all the operators loaded by the Plugin Manager.
+     *
      * @return the set of all operators that were loaded.
      */
     public Set<String> getAllOperators() {
@@ -199,6 +208,7 @@ public class PluginManager {
 
     /**
      * Gets all the number implementations loaded by the Plugin Manager
+     *
      * @return the set of all implementations that were loaded
      */
     public Set<String> getAllNumbers() {
@@ -207,17 +217,19 @@ public class PluginManager {
 
     /**
      * Adds a plugin change listener to this plugin manager.
+     *
      * @param listener the listener to add.
      */
-    public void addListener(PluginListener listener){
+    public void addListener(PluginListener listener) {
         listeners.add(listener);
     }
 
     /**
      * Remove the plugin change listener from this plugin manager.
+     *
      * @param listener the listener to remove.
      */
-    public void removeListener(PluginListener listener){
+    public void removeListener(PluginListener listener) {
         listeners.remove(listener);
     }
 

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

@@ -25,7 +25,7 @@ public class StandardPlugin extends Plugin {
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
             NumberInterface sum = params[0];
-            for(int i = 1; i < params.length; i++){
+            for (int i = 1; i < params.length; i++) {
                 sum = sum.add(params[i]);
             }
             return sum;
@@ -42,7 +42,7 @@ public class StandardPlugin extends Plugin {
             return params[0].subtract(params[1]);
         }
     });
-    public static final Operator OP_MULTIPLY = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
+    public static final Operator OP_MULTIPLY = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1, new Function() {
         @Override
         protected boolean matchesParams(NumberInterface[] params) {
             return params.length >= 1;
@@ -51,13 +51,13 @@ public class StandardPlugin extends Plugin {
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
             NumberInterface product = params[0];
-            for(int i = 1; i < params.length; i++){
+            for (int i = 1; i < params.length; i++) {
                 product = product.multiply(params[i]);
             }
             return product;
         }
     });
-    public static final Operator OP_DIVIDE = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
+    public static final Operator OP_DIVIDE = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 1, new Function() {
         @Override
         protected boolean matchesParams(NumberInterface[] params) {
             return params.length >= 1;
@@ -66,23 +66,12 @@ public class StandardPlugin extends Plugin {
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
             NumberInterface product = params[0];
-            for(int i = 1; i < params.length; i++){
+            for (int i = 1; i < params.length; i++) {
                 product = product.multiply(params[i]);
             }
             return product;
         }
     });
-    public static final Operator OP_CARET = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2, new Function() {
-        @Override
-        protected boolean matchesParams(NumberInterface[] params) {
-            return params.length == 2;
-        }
-
-        @Override
-        protected NumberInterface applyInternal(NumberInterface[] params) {
-            return FUNCTION_EXP.apply(FUNCTION_LN.apply(params[0]).multiply(params[1]));
-        }
-    });
     public static final Operator OP_FACTORIAL = new Operator(OperatorAssociativity.RIGHT, OperatorType.UNARY_POSTFIX, 0, new Function() {
         //private HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> storedList = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
         @Override
@@ -92,13 +81,13 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
-            if(params[0].signum() == 0){
+            if (params[0].signum() == 0) {
                 return (new NaiveNumber(1)).promoteTo(params[0].getClass());
             }
             NumberInterface factorial = params[0];
             NumberInterface multiplier = params[0];
             //It is necessary to later prevent calls of factorial on anything but non-negative integers.
-            while((multiplier = multiplier.subtract(NaiveNumber.ONE.promoteTo(multiplier.getClass()))).signum() == 1){
+            while ((multiplier = multiplier.subtract(NaiveNumber.ONE.promoteTo(multiplier.getClass()))).signum() == 1) {
                 factorial = factorial.multiply(multiplier);
             }
             return factorial;
@@ -131,7 +120,7 @@ public class StandardPlugin extends Plugin {
             boolean takeReciprocal = params[0].signum() == -1;
             params[0] = FUNCTION_ABS.apply(params[0]);
             NumberInterface sum = sumSeries(params[0], StandardPlugin::getExpSeriesTerm, getNTermsExp(getMaxError(params[0]), params[0]));
-            if(takeReciprocal){
+            if (takeReciprocal) {
                 sum = NaiveNumber.ONE.promoteTo(sum.getClass()).divide(sum);
             }
             return sum;
@@ -147,19 +136,18 @@ public class StandardPlugin extends Plugin {
         protected NumberInterface applyInternal(NumberInterface[] params) {
             NumberInterface param = params[0];
             int powersOf2 = 0;
-            while(FUNCTION_ABS.apply(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass()))).compareTo((new NaiveNumber(0.1)).promoteTo(param.getClass())) >= 0){
+            while (FUNCTION_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) {
+                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) {
+                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
                         break;
                         //No infinite loop for you.
                     }
-                }
+                } else {
-                else {
                     param = param.multiply(new NaiveNumber(2).promoteTo(param.getClass()));
                     powersOf2--;
-                    if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
                         break;
                         //No infinite loop for you.
                     }
@@ -174,14 +162,14 @@ 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(NumberInterface x) {
             NumberInterface maxError = 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(FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0){
+            while (FUNCTION_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();
+                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;
@@ -192,7 +180,7 @@ 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(NumberInterface number) {
             NumberInterface maxError = 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)
@@ -201,7 +189,7 @@ public class StandardPlugin extends Plugin {
             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){
+            while (a.compareTo(maxError) >= 1) {
                 n++;
                 a = a.divide((new NaiveNumber(3)).promoteTo(number.getClass()));
                 b = b.divide((new NaiveNumber(4)).promoteTo(number.getClass()));
@@ -211,6 +199,17 @@ public class StandardPlugin extends Plugin {
             return sum;
         }
     };
+    public static final Operator OP_CARET = new Operator(OperatorAssociativity.RIGHT, OperatorType.BINARY_INFIX, 2, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 2;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return FUNCTION_EXP.apply(FUNCTION_LN.apply(params[0]).multiply(params[1]));
+        }
+    });
     public static final Function FUNCTION_SQRT = new Function() {
         @Override
         protected boolean matchesParams(NumberInterface[] params) {
@@ -227,42 +226,21 @@ public class StandardPlugin extends Plugin {
         super(manager);
     }
 
-    @Override
-    public void onEnable() {
-        registerNumber("naive", NaiveNumber.class);
-        registerNumber("precise", PreciseNumber.class);
-
-        registerOperator("+", OP_ADD);
-        registerOperator("-", OP_SUBTRACT);
-        registerOperator("*", OP_MULTIPLY);
-        registerOperator("/", OP_DIVIDE);
-        registerOperator("^", OP_CARET);
-        registerOperator("!", OP_FACTORIAL);
-
-        registerFunction("abs", FUNCTION_ABS);
-        registerFunction("exp", FUNCTION_EXP);
-        registerFunction("ln", FUNCTION_LN);
-        registerFunction("sqrt",FUNCTION_SQRT);
-    }
-
-    @Override
-    public void onDisable() {
-
-    }
-
     /**
      * Returns the nth term of the Taylor series (centered at 0) of e^x
+     *
      * @param n the term required (n >= 0).
      * @param x the real number at which the series is evaluated.
      * @return the nth term of the series.
      */
-    private static NumberInterface getExpSeriesTerm(int n, NumberInterface x){
+    private static NumberInterface getExpSeriesTerm(int n, NumberInterface x) {
         return x.intPow(n).divide(OP_FACTORIAL.getFunction().apply((new NaiveNumber(n)).promoteTo(x.getClass())));
     }
 
     /**
      * Returns the number of terms needed to evaluate the exponential function (at x)
      * such that the error is at most maxError.
+     *
      * @param maxError Maximum error permissible (This should probably be positive.)
      * @param x        where the function is evaluated.
      * @return the number of terms needed to evaluated the exponential function.
@@ -281,17 +259,17 @@ public class StandardPlugin extends Plugin {
         return n;
     }
 
-
     /**
      * 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){
+    private static NumberInterface sumSeries(NumberInterface x, BiFunction<Integer, NumberInterface, NumberInterface> nthTermFunction, int n) {
         NumberInterface sum = NaiveNumber.ZERO.promoteTo(x.getClass());
-        for(int i = 0; i <= n; i++){
+        for (int i = 0; i <= n; i++) {
             sum = sum.add(nthTermFunction.apply(i, x));
         }
         return sum;
@@ -299,11 +277,35 @@ public class StandardPlugin extends Plugin {
 
     /**
      * Returns the maximum error based on the precision of the class of number.
+     *
      * @param number Any instance of the NumberInterface in question (should return an appropriate precision).
      * @return the maximum error.
      */
-    private static NumberInterface getMaxError(NumberInterface number){
+    private static NumberInterface getMaxError(NumberInterface number) {
         return (new NaiveNumber(10)).promoteTo(number.getClass()).intPow(-number.getMaxPrecision());
     }
 
+    @Override
+    public void onEnable() {
+        registerNumber("naive", NaiveNumber.class);
+        registerNumber("precise", PreciseNumber.class);
+
+        registerOperator("+", OP_ADD);
+        registerOperator("-", OP_SUBTRACT);
+        registerOperator("*", OP_MULTIPLY);
+        registerOperator("/", OP_DIVIDE);
+        registerOperator("^", OP_CARET);
+        registerOperator("!", OP_FACTORIAL);
+
+        registerFunction("abs", FUNCTION_ABS);
+        registerFunction("exp", FUNCTION_EXP);
+        registerFunction("ln", FUNCTION_LN);
+        registerFunction("sqrt", FUNCTION_SQRT);
+    }
+
+    @Override
+    public void onDisable() {
+
+    }
+
 }

src/main/java/org/nwapw/abacus/tree/BinaryInfixNode.java

@@ -18,25 +18,28 @@ public class BinaryInfixNode extends TreeNode {
      */
     private TreeNode right;
 
-    private BinaryInfixNode() {}
+    private BinaryInfixNode() {
+    }
 
     /**
      * Creates a new operation node with the given operation
      * and no child nodes.
+     *
      * @param operation the operation.
      */
-    public BinaryInfixNode(String operation){
+    public BinaryInfixNode(String operation) {
         this(operation, null, null);
     }
 
     /**
      * Creates a new operation node with the given operation
      * and child nodes.
+     *
      * @param operation the operation.
      * @param left      the left node of the expression.
      * @param right     the right node of the expression.
      */
-    public BinaryInfixNode(String operation, TreeNode left, TreeNode right){
+    public BinaryInfixNode(String operation, TreeNode left, TreeNode right) {
         this.operation = operation;
         this.left = left;
         this.right = right;
@@ -44,6 +47,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Gets the operation in this node.
+     *
      * @return the operation in this node.
      */
     public String getOperation() {
@@ -52,6 +56,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Gets the left sub-expression of this node.
+     *
      * @return the left node.
      */
     public TreeNode getLeft() {
@@ -60,6 +65,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Sets the left sub-expression of this node.
+     *
      * @param left the sub-expression to apply.
      */
     public void setLeft(TreeNode left) {
@@ -68,6 +74,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Gets the right sub-expression of this node.
+     *
      * @return the right node.
      */
     public TreeNode getRight() {
@@ -76,6 +83,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Sets the right sub-expression of this node.
+     *
      * @param right the sub-expression to apply.
      */
     public void setRight(TreeNode right) {
@@ -86,7 +94,7 @@ public class BinaryInfixNode extends TreeNode {
     public <T> T reduce(Reducer<T> reducer) {
         T leftReduce = left.reduce(reducer);
         T rightReduce = right.reduce(reducer);
-        if(leftReduce == null || rightReduce == null) return null;
+        if (leftReduce == null || rightReduce == null) return null;
         return reducer.reduceNode(this, leftReduce, rightReduce);
     }
 

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

@@ -20,19 +20,22 @@ public class FunctionNode extends TreeNode {
     /**
      * Creates a function node with no function.
      */
-    private FunctionNode() { }
+    private FunctionNode() {
+    }
 
     /**
      * Creates a new function node with the given function name.
+     *
      * @param function the function name.
      */
-    public FunctionNode(String function){
+    public FunctionNode(String function) {
         this.function = function;
         children = new ArrayList<>();
     }
 
     /**
      * Gets the function name for this node.
+     *
      * @return the function name.
      */
     public String getFunction() {
@@ -41,14 +44,16 @@ public class FunctionNode extends TreeNode {
 
     /**
      * Adds a child to the end of this node's child list.
+     *
      * @param node the child to add.
      */
-    public void appendChild(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) {
@@ -58,9 +63,9 @@ public class FunctionNode extends TreeNode {
     @Override
     public <T> T reduce(Reducer<T> reducer) {
         Object[] reducedChildren = new Object[children.size()];
-        for(int i = 0; i < reducedChildren.length; i++){
+        for (int i = 0; i < reducedChildren.length; i++) {
             reducedChildren[i] = children.get(i).reduce(reducer);
-            if(reducedChildren[i] == null) return null;
+            if (reducedChildren[i] == null) return null;
         }
         return reducer.reduceNode(this, reducedChildren);
     }
@@ -70,7 +75,7 @@ public class FunctionNode extends TreeNode {
         StringBuilder buffer = new StringBuilder();
         buffer.append(function);
         buffer.append("(");
-        for(int i = 0; i < children.size(); i++){
+        for (int i = 0; i < children.size(); i++) {
             buffer.append(children.get(i));
             buffer.append(i == children.size() - 1 ? "" : ", ");
         }

src/main/java/org/nwapw/abacus/tree/NumberNode.java

@@ -1,6 +1,5 @@
 package org.nwapw.abacus.tree;
 
-import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 
 /**
@@ -16,20 +15,22 @@ public class NumberNode extends TreeNode {
     /**
      * Creates a number node with no number.
      */
-    public NumberNode(){
+    public NumberNode() {
         number = null;
     }
 
     /**
      * Creates a new number node with the given double value.
+     *
      * @param newNumber the number for which to create a number node.
      */
-    public NumberNode(NumberInterface newNumber){
+    public NumberNode(NumberInterface newNumber) {
         this.number = newNumber;
     }
 
     /**
      * Gets the number value of this node.
+     *
      * @return the number value of this node.
      */
     public NumberInterface getNumber() {

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

@@ -17,34 +17,35 @@ public class NumberReducer implements Reducer<NumberInterface> {
 
     /**
      * Creates a new number reducer.
+     *
      * @param abacus the calculator instance.
      */
-    public NumberReducer(Abacus abacus){
+    public NumberReducer(Abacus abacus) {
         this.abacus = abacus;
     }
 
     @Override
     public NumberInterface reduceNode(TreeNode node, Object... children) {
-        if(node instanceof NumberNode) {
+        if (node instanceof NumberNode) {
             return ((NumberNode) node).getNumber();
-        } else if(node instanceof BinaryInfixNode){
+        } else if (node instanceof BinaryInfixNode) {
             NumberInterface left = (NumberInterface) children[0];
             NumberInterface right = (NumberInterface) children[1];
             Function function = abacus.getPluginManager().operatorFor(((BinaryInfixNode) node).getOperation()).getFunction();
-            if(function == null) return null;
+            if (function == null) return null;
             return function.apply(left, right);
-        } else if(node instanceof UnaryPrefixNode) {
+        } else if (node instanceof UnaryPrefixNode) {
             NumberInterface child = (NumberInterface) children[0];
             Function functionn = abacus.getPluginManager().operatorFor(((UnaryPrefixNode) node).getOperation()).getFunction();
-            if(functionn == null) return null;
+            if (functionn == null) return null;
             return functionn.apply(child);
-        } else if(node instanceof FunctionNode){
+        } else if (node instanceof FunctionNode) {
             NumberInterface[] convertedChildren = new NumberInterface[children.length];
-            for(int i = 0; i < convertedChildren.length; i++){
+            for (int i = 0; i < convertedChildren.length; i++) {
                 convertedChildren[i] = (NumberInterface) children[i];
             }
             Function function = abacus.getPluginManager().functionFor(((FunctionNode) node).getFunction());
-            if(function == null) return null;
+            if (function == null) return null;
             return function.apply(convertedChildren);
         }
         return null;

src/main/java/org/nwapw/abacus/tree/Reducer.java

@@ -2,16 +2,18 @@ package org.nwapw.abacus.tree;
 
 /**
  * Interface used to reduce a tree into a single value.
+ *
  * @param <T> the value to reduce into.
  */
 public interface Reducer<T> {
 
     /**
      * Reduces the given tree into a single value of type T.
+     *
      * @param node     the node being passed in to be reduced.
      * @param children the already-reduced children of this node.
      * @return the resulting value from the reduce.
      */
-    public T reduceNode(TreeNode node, Object...children);
+    public T reduceNode(TreeNode node, Object... children);
 
 }

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

@@ -16,9 +16,10 @@ public enum TokenType {
 
     /**
      * Creates a new token type with the given priority.
+     *
      * @param priority the priority of this token type.
      */
-    TokenType(int priority){
+    TokenType(int priority) {
         this.priority = priority;
     }
 

src/main/java/org/nwapw/abacus/tree/TreeNode.java

@@ -1,11 +1,5 @@
 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 java.util.*;
-
 /**
  * An abstract class that represents an expression tree node.
  */
@@ -13,6 +7,7 @@ public abstract class TreeNode {
 
     /**
      * The function that reduces a tree to a single vale.
+     *
      * @param reducer the reducer used to reduce the tree.
      * @param <T>     the type the reducer produces.
      * @return the result of the reduction, or null on error.

src/main/java/org/nwapw/abacus/tree/UnaryPrefixNode.java

@@ -13,18 +13,20 @@ public class UnaryPrefixNode extends TreeNode {
 
     /**
      * Creates a new node with the given operation and no child.
+     *
      * @param operation the operation for this node.
      */
-    public UnaryPrefixNode(String operation){
+    public UnaryPrefixNode(String operation) {
         this(operation, null);
     }
 
     /**
      * Creates a new node with the given operation and child.
+     *
      * @param operation the operation for this node.
      * @param applyTo   the node to apply the function to.
      */
-    public UnaryPrefixNode(String operation, TreeNode applyTo){
+    public UnaryPrefixNode(String operation, TreeNode applyTo) {
         this.operation = operation;
         this.applyTo = applyTo;
     }
@@ -32,12 +34,13 @@ public class UnaryPrefixNode extends TreeNode {
     @Override
     public <T> T reduce(Reducer<T> reducer) {
         Object reducedChild = applyTo.reduce(reducer);
-        if(reducedChild == null) return null;
+        if (reducedChild == null) return null;
         return reducer.reduceNode(this, reducedChild);
     }
 
     /**
      * Gets the operation of this node.
+     *
      * @return the operation this node performs.
      */
     public String getOperation() {
@@ -46,6 +49,7 @@ public class UnaryPrefixNode extends TreeNode {
 
     /**
      * Gets the node to which this node's operation applies.
+     *
      * @return the tree node to which the operation will be applied.
      */
     public TreeNode getApplyTo() {

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

@@ -2,9 +2,7 @@ package org.nwapw.abacus.window;
 
 import org.nwapw.abacus.tree.TreeNode;
 
-import javax.swing.event.TableModelListener;
 import javax.swing.table.AbstractTableModel;
-import javax.swing.table.TableModel;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -31,30 +29,6 @@ public class HistoryTableModel extends AbstractTableModel {
             TreeNode.class,
             String.class
     };
-
-    /**
-     * Class used specifically to hold data about
-     * the previous entries into the calculator.
-     */
-    public static class HistoryEntry {
-        public String input;
-        public TreeNode parsedInput;
-        public String output;
-
-        public HistoryEntry(String input, TreeNode parsedInput, String output){
-            this.input = input;
-            this.parsedInput = parsedInput;
-            this.output = output;
-        }
-
-        Object nthValue(int n){
-            if(n == 0) return input;
-            if(n == 1) return parsedInput;
-            if(n == 2) return output;
-            return null;
-        }
-    }
-
     /**
      * The list of entries.
      */
@@ -69,9 +43,10 @@ public class HistoryTableModel extends AbstractTableModel {
 
     /**
      * Adds an entry to the model.
+     *
      * @param entry the entry to add.
      */
-    public void addEntry(HistoryEntry entry){
+    public void addEntry(HistoryEntry entry) {
         entries.add(entry);
     }
 
@@ -105,4 +80,27 @@ public class HistoryTableModel extends AbstractTableModel {
         return entries.get(rowIndex).nthValue(columnIndex);
     }
 
+    /**
+     * Class used specifically to hold data about
+     * the previous entries into the calculator.
+     */
+    public static class HistoryEntry {
+        public String input;
+        public TreeNode parsedInput;
+        public String output;
+
+        public HistoryEntry(String input, TreeNode parsedInput, String output) {
+            this.input = input;
+            this.parsedInput = parsedInput;
+            this.output = output;
+        }
+
+        Object nthValue(int n) {
+            if (n == 0) return input;
+            if (n == 1) return parsedInput;
+            if (n == 2) return output;
+            return null;
+        }
+    }
+
 }

src/main/java/org/nwapw/abacus/window/Window.java

@@ -119,12 +119,12 @@ public class Window extends JFrame {
      */
     private ActionListener evaluateListener = (event) -> {
         TreeNode parsedExpression = abacus.parseString(inputField.getText());
-        if(parsedExpression == null){
+        if (parsedExpression == null) {
             lastOutputArea.setText(SYNTAX_ERR_STRING);
             return;
         }
         NumberInterface numberInterface = abacus.evaluateTree(parsedExpression);
-        if(numberInterface == null) {
+        if (numberInterface == null) {
             lastOutputArea.setText(EVAL_ERR_STRING);
             return;
         }
@@ -146,9 +146,10 @@ public class Window extends JFrame {
 
     /**
      * Creates a new window with the given manager.
+     *
      * @param abacus the calculator instance to interact with other components.
      */
-    public Window(Abacus abacus){
+    public Window(Abacus abacus) {
         this();
         this.abacus = abacus;
     }
@@ -218,11 +219,11 @@ public class Window extends JFrame {
             inputField.setEnabled(enabled);
             inputEnterButton.setEnabled(enabled);
 
-            for(ActionListener removingListener : inputEnterButton.getActionListeners()){
+            for (ActionListener removingListener : inputEnterButton.getActionListeners()) {
                 inputEnterButton.removeActionListener(removingListener);
                 inputField.removeActionListener(removingListener);
             }
-            if(listener != null){
+            if (listener != null) {
                 inputEnterButton.addActionListener(listener);
                 inputField.addActionListener(listener);
             }
@@ -236,7 +237,7 @@ public class Window extends JFrame {
             @Override
             public void mouseClicked(MouseEvent e) {
                 Point clickPoint = e.getPoint();
-                if(e.getClickCount() == 2){
+                if (e.getClickCount() == 2) {
                     int row = historyTable.rowAtPoint(clickPoint);
                     int column = historyTable.columnAtPoint(clickPoint);
                     String toCopy = historyTable.getValueAt(row, column).toString();

src/test/java/org/nwapw/abacus/tests/LexerTests.java

@@ -10,7 +10,7 @@ import java.util.List;
 public class LexerTests {
 
     @Test
-    public void testBasicSuccess(){
+    public void testBasicSuccess() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("abc", 0);
         lexer.register("def", 1);
@@ -22,7 +22,7 @@ public class LexerTests {
     }
 
     @Test
-    public void testBasicFailure(){
+    public void testBasicFailure() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("abc", 0);
         lexer.register("def", 1);
@@ -30,20 +30,20 @@ public class LexerTests {
     }
 
     @Test
-    public void testNoPatterns(){
+    public void testNoPatterns() {
         Lexer<Integer> lexer = new Lexer<>();
         Assert.assertNull(lexer.lexAll("abcdefabc", 0, Integer::compare));
     }
 
     @Test
-    public void testEmptyMatches(){
+    public void testEmptyMatches() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("a?", 0);
         Assert.assertNull(lexer.lexAll("", 0, Integer::compare));
     }
 
     @Test
-    public void testOneOrMore(){
+    public void testOneOrMore() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("a+", 0);
         List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
@@ -52,7 +52,7 @@ public class LexerTests {
     }
 
     @Test
-    public void testZeroOrMore(){
+    public void testZeroOrMore() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("a*", 0);
         List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
@@ -61,7 +61,7 @@ public class LexerTests {
     }
 
     @Test
-    public void testZeroOrOne(){
+    public void testZeroOrOne() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("a?", 0);
         List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
@@ -70,7 +70,7 @@ public class LexerTests {
     }
 
     @Test
-    public void testGreedyMatching(){
+    public void testGreedyMatching() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("a*a", 0);
         List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
@@ -79,20 +79,20 @@ public class LexerTests {
     }
 
     @Test
-    public void testAnyCharacter(){
+    public void testAnyCharacter() {
         String testString = "abcdef";
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register(".", 0);
         List<Match<Integer>> tokens = lexer.lexAll(testString, 0, Integer::compare);
         Assert.assertNotNull(tokens);
         Assert.assertEquals(tokens.size(), testString.length());
-        for(int i = 0; i < tokens.size(); i++){
+        for (int i = 0; i < tokens.size(); i++) {
             Assert.assertEquals(testString.substring(i, i + 1), tokens.get(i).getContent());
         }
     }
 
     @Test
-    public void testBasicGroup(){
+    public void testBasicGroup() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("(abc)", 0);
         List<Match<Integer>> tokens = lexer.lexAll("abc", 0, Integer::compare);
@@ -102,27 +102,27 @@ public class LexerTests {
     }
 
     @Test
-    public void testBasicRangeSuccess(){
+    public void testBasicRangeSuccess() {
         String testString = "abcdef";
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("[a-f]", 0);
         List<Match<Integer>> tokens = lexer.lexAll(testString, 0, Integer::compare);
         Assert.assertNotNull(tokens);
         Assert.assertEquals(testString.length(), tokens.size());
-        for(int i = 0; i < tokens.size(); i++){
+        for (int i = 0; i < tokens.size(); i++) {
             Assert.assertEquals(testString.substring(i, i + 1), tokens.get(i).getContent());
         }
     }
 
     @Test
-    public void testBasicRangeFailure(){
+    public void testBasicRangeFailure() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("[a-f]", 0);
         Assert.assertNull(lexer.lexAll("g", 0, Integer::compare));
     }
 
     @Test
-    public void testGroupAndOperator(){
+    public void testGroupAndOperator() {
         Lexer<Integer> lexer = new Lexer<>();
         lexer.register("(abc)+", 0);
         List<Match<Integer>> tokens = lexer.lexAll("abcabc", 0, Integer::compare);

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

@@ -64,17 +64,17 @@ public class TokenizerTests {
 
     @Test
     public void testInteger() {
-        assertTokensMatch(lexerTokenizer.tokenizeString("11"), new TokenType[]{ TokenType.NUM } );
+        assertTokensMatch(lexerTokenizer.tokenizeString("11"), new TokenType[]{TokenType.NUM});
     }
 
     @Test
     public void testLeadingZeroDecimal() {
-        assertTokensMatch(lexerTokenizer.tokenizeString("0.1"), new TokenType[]{ TokenType.NUM } );
+        assertTokensMatch(lexerTokenizer.tokenizeString("0.1"), new TokenType[]{TokenType.NUM});
     }
 
     @Test
     public void testNonLeadingDecimal() {
-        assertTokensMatch(lexerTokenizer.tokenizeString(".1"), new TokenType[]{ TokenType.NUM } );
+        assertTokensMatch(lexerTokenizer.tokenizeString(".1"), new TokenType[]{TokenType.NUM});
     }
 
     @Test
@@ -102,7 +102,7 @@ public class TokenizerTests {
     }
 
     @Test
-    public void testOperatorParsing(){
+    public void testOperatorParsing() {
         TokenType[] types = {
                 TokenType.NUM,
                 TokenType.OP,
@@ -112,7 +112,7 @@ public class TokenizerTests {
     }
 
     @Test
-    public void testSanitizedOperators(){
+    public void testSanitizedOperators() {
         TokenType[] types = {
                 TokenType.NUM,
                 TokenType.OP,