add stop on node

[ci skip]

.travis.yml

@@ -0,0 +1 @@
+language: java

README.md

@@ -1,4 +1,6 @@
 # abacus
+[![Build Status](https://travis-ci.org/DanilaFe/abacus.svg?branch=master)](https://travis-ci.org/DanilaFe/abacus)
+
 Summer project for NWAPW.
 Created by Arthur Drobot, Danila Fedorin and Riley Jones.
 

build.gradle

@@ -1,14 +1,6 @@
 apply plugin: 'java'
 apply plugin: 'application'
 
-sourceSets {
-  main {
-    java {
-      srcDirs = ['src']
-    }
-  }
-}
-
 repositories {
   mavenCentral()
 }

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

@@ -34,10 +34,6 @@ public class Abacus {
      */
     public static final File CONFIG_FILE = new File("config.toml");
 
-    /**
-     * The main Abacus UI.
-     */
-    private Window mainUi;
     /**
      * The plugin manager responsible for
      * loading and unloading plugins,
@@ -57,13 +53,15 @@ public class Abacus {
      * from a string.
      */
     private TreeBuilder treeBuilder;
-
+    private Window window;
+    public boolean getStop(){
+        return window.getStop();
+    }
     /**
      * Creates a new instance of the Abacus calculator.
      */
     public Abacus() {
-        pluginManager = new PluginManager(this);
+        pluginManager = new PluginManager();
-        mainUi = new Window(this);
         numberReducer = new NumberReducer(this);
         configuration = new ConfigurationObject(CONFIG_FILE);
         configuration.save(CONFIG_FILE);
@@ -81,12 +79,21 @@ public class Abacus {
             e.printStackTrace();
         }
         pluginManager.load();
+    }
 
-        mainUi.setVisible(true);
+    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() {
@@ -95,23 +102,17 @@ public class Abacus {
 
     /**
      * Gets the current plugin manager,
+     *
      * @return the plugin manager in this abacus instance.
      */
     public PluginManager getPluginManager() {
         return pluginManager;
     }
 
-    /**
-     * Gets the current UI.
-     * @return the UI window in this abacus instance.
-     */
-    public Window getMainUi() {
-        return mainUi;
-    }
-
     /**
      * Get the reducer that is responsible for transforming
      * an expression into a number.
+     *
      * @return the number reducer in this abacus instance.
      */
     public NumberReducer getNumberReducer() {
@@ -120,6 +121,7 @@ public class Abacus {
 
     /**
      * Gets the configuration object associated with this instance.
+     *
      * @return the configuration object.
      */
     public ConfigurationObject getConfiguration() {
@@ -129,16 +131,18 @@ 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) {
-        return treeBuilder.fromString(input);
+        return treeBuilder.fromString(input,this);
     }
 
     /**
      * 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.
      */
@@ -146,6 +150,12 @@ public class Abacus {
         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) {
         Class<? extends NumberInterface> toInstantiate =
                 pluginManager.numberFor(configuration.getNumberImplementation());
@@ -159,13 +169,7 @@ public class Abacus {
         return null;
     }
 
-    public static void main(String[] args){
+    public void setWindow(Window window) {
-        try {
+        this.window = window;
-            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
-        } catch (ClassNotFoundException | InstantiationException | UnsupportedLookAndFeelException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-
-        new Abacus();
     }
 }

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

@@ -23,53 +23,9 @@ 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) {
@@ -80,6 +36,7 @@ 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) {
@@ -102,4 +59,53 @@ public class 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,6 +40,7 @@ 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.
      */

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

@@ -24,6 +24,7 @@ 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.
@@ -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,47 +10,11 @@ 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> {
 
-    /**
-     * 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>{
-        /**
-         * The name of the entry.
-         */
-        public String name;
-        /**
-         * The id of the entry.
-         */
-        public T id;
-
-        /**
-         * 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){
-            this.name = name;
-            this.id = id;
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(name, id);
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-            return obj instanceof PatternEntry &&
-                    ((PatternEntry) obj).name.equals(name) &&
-                    ((PatternEntry) obj).id.equals(id);
-        }
-    }
-
     /**
      * The registered patterns.
      */
@@ -65,6 +29,7 @@ public class Lexer<T> {
 
     /**
      * Registers a single pattern.
+     *
      * @param pattern the pattern regex
      * @param id      the ID by which to identify the pattern.
      */
@@ -75,6 +40,7 @@ public class Lexer<T> {
 
     /**
      * Unregisters a pattern.
+     *
      * @param pattern the pattern to unregister
      * @param id      the ID by which to identify the pattern.
      */
@@ -84,6 +50,7 @@ public class Lexer<T> {
 
     /**
      * 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.
@@ -122,6 +89,7 @@ public class Lexer<T> {
 
     /**
      * 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.
@@ -141,4 +109,43 @@ public class Lexer<T> {
         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> {
+        /**
+         * The name of the entry.
+         */
+        public String name;
+        /**
+         * The id of the entry.
+         */
+        public T id;
+
+        /**
+         * 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) {
+            this.name = name;
+            this.id = id;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(name, id);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            return obj instanceof PatternEntry &&
+                    ((PatternEntry) obj).name.equals(name) &&
+                    ((PatternEntry) obj).id.equals(id);
+        }
+    }
+
 }

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,6 +14,7 @@ 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) {
@@ -21,6 +23,7 @@ public class EndNode<T> extends PatternNode<T> {
 
     /**
      * Gets the pattern ID.
+     *
      * @return the pattern ID.
      */
     public T getPatternId() {

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

@@ -1,10 +1,10 @@
 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> {

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,6 +18,7 @@ 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.
      */
@@ -27,6 +29,7 @@ public class Match<T> {
 
     /**
      * 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,9 +41,49 @@ 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.
      */
@@ -54,6 +95,7 @@ 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.
      */
@@ -72,6 +114,7 @@ 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.
      */
@@ -88,6 +131,7 @@ 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.
      */
@@ -104,6 +148,7 @@ 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() {
@@ -116,6 +161,7 @@ public class Pattern<T> {
 
     /**
      * Parses a [] range from the input into a chain.
+     *
      * @return the resulting chain, or null on error.
      */
     private PatternChain<T> parseOr() {
@@ -142,6 +188,7 @@ public class Pattern<T> {
 
     /**
      * 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.
@@ -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,6 +19,7 @@ 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.
      */
@@ -28,6 +30,7 @@ public class PatternChain<T> {
 
     /**
      * Creates a chain that starts and ends with the same node.
+     *
      * @param node the node to use.
      */
     public PatternChain(PatternNode<T> node) {
@@ -45,6 +48,7 @@ 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) {
@@ -61,6 +65,7 @@ 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) {

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> {
@@ -29,6 +29,7 @@ public class PatternNode<T> {
     /**
      * 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.
      */
@@ -38,6 +39,7 @@ public class PatternNode<T> {
 
     /**
      * 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.
      */
@@ -47,6 +49,7 @@ public class PatternNode<T> {
 
     /**
      * Adds this node in a collection of other nodes.
+     *
      * @param into the collection to add into.
      */
     public void addInto(Collection<PatternNode<T>> into) {
@@ -55,6 +58,7 @@ public class PatternNode<T> {
 
     /**
      * 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) {

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,6 +18,7 @@ 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.
      */

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,6 +14,7 @@ public class ValueNode<T> extends PatternNode<T> {
 
     /**
      * Creates a new node that matches the given character.
+     *
      * @param value
      */
     public ValueNode(char 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() {

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

@@ -25,6 +25,7 @@ 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.
      */
@@ -34,6 +35,7 @@ public class PreciseNumber implements NumberInterface{
 
     /**
      * Constructs a precise number from the given BigDecimal.
+     *
      * @param value a BigDecimal object representing the value of the number.
      */
     public PreciseNumber(BigDecimal value) {

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

@@ -1,5 +1,6 @@
 package org.nwapw.abacus.parsing;
 
+import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.tree.TreeNode;
 
 import java.util.List;
@@ -7,14 +8,16 @@ 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.
      */
-    public TreeNode constructTree(List<T> tokens);
+    public TreeNode constructTree(List<T> tokens,Abacus trace);
 }

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

@@ -34,8 +34,11 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
      */
     private Map<String, OperatorType> typeMap;
 
+    //private Abacus trace;
+
     /**
      * Creates a new Shunting Yard parser with the given Abacus instance.
+     *
      * @param abacus the abacus instance.
      */
     public ShuntingYardParser(Abacus abacus) {
@@ -47,6 +50,7 @@ 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.
      */
@@ -110,10 +114,12 @@ 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,Abacus trace) {
+        //this.trace = trace;
         if (matches.size() == 0) return null;
         Match<TokenType> match = matches.remove(0);
         TokenType matchType = match.getType();
@@ -121,22 +127,22 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
             String operator = match.getContent();
             OperatorType type = typeMap.get(operator);
             if (type == OperatorType.BINARY_INFIX) {
-                TreeNode right = constructRecursive(matches);
+                TreeNode right = constructRecursive(matches,trace);
-                TreeNode left = constructRecursive(matches);
+                TreeNode left = constructRecursive(matches,trace);
                 if (left == null || right == null) return null;
-                else return new BinaryInfixNode(operator, left, right);
+                else return new BinaryInfixNode(operator, left, right,trace);
             } else {
-                TreeNode applyTo = constructRecursive(matches);
+                TreeNode applyTo = constructRecursive(matches,trace);
                 if (applyTo == null) return null;
-                else return new UnaryPrefixNode(operator, applyTo);
+                else return new UnaryPrefixNode(operator, applyTo,trace);
             }
         } else if (matchType == TokenType.NUM) {
             return new NumberNode(abacus.numberFromString(match.getContent()));
         } else if (matchType == TokenType.FUNCTION) {
             String functionName = match.getContent();
-            FunctionNode node = new FunctionNode(functionName);
+            FunctionNode node = new FunctionNode(functionName,trace);
             while (!matches.isEmpty() && matches.get(0).getType() != TokenType.INTERNAL_FUNCTION_END) {
-                TreeNode argument = constructRecursive(matches);
+                TreeNode argument = constructRecursive(matches,trace);
                 if (argument == null) return null;
                 node.prependChild(argument);
             }
@@ -148,10 +154,10 @@ public class ShuntingYardParser implements Parser<Match<TokenType>>, PluginListe
     }
 
     @Override
-    public TreeNode constructTree(List<Match<TokenType>> tokens) {
+    public TreeNode constructTree(List<Match<TokenType>> tokens,Abacus trace) {
         tokens = intoPostfix(new ArrayList<>(tokens));
         Collections.reverse(tokens);
-        return constructRecursive(tokens);
+        return constructRecursive(tokens,trace);
     }
 
     @Override

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

@@ -0,0 +1,51 @@
+package org.nwapw.abacus.parsing;
+
+import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.tree.TreeNode;
+
+import java.util.List;
+
+/**
+ * TreeBuilder class used to piece together a Tokenizer and
+ * Parser of the same kind. This is used to essentially avoid
+ * 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> {
+
+    /**
+     * The tokenizer used to convert a string into tokens.
+     */
+    private Tokenizer<T> tokenizer;
+    /**
+     * The parser used to parse a list of tokens into a tree.
+     */
+    private Parser<T> parser;
+
+    /**
+     * 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) {
+        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,Abacus trace) {
+        List<T> tokens = tokenizer.tokenizeString(input);
+        if (tokens == null) return null;
+        return parser.constructTree(tokens,trace);
+    }
+
+}

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.
@@ -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,6 +57,7 @@ public abstract class Plugin {
 
     /**
      * Gets the list of functions provided by this plugin.
+     *
      * @return the list of registered functions.
      */
     public final Set<String> providedFunctions() {
@@ -63,6 +66,7 @@ public abstract class Plugin {
 
     /**
      * Gets the list of functions provided by this plugin.
+     *
      * @return the list of registered functions.
      */
     public final Set<String> providedOperators() {
@@ -71,6 +75,7 @@ public abstract class Plugin {
 
     /**
      * Gets the list of all numbers provided by this plugin.
+     *
      * @return the list of registered numbers.
      */
     public final Set<String> providedNumbers() {
@@ -79,6 +84,7 @@ public abstract class Plugin {
 
     /**
      * 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,6 +104,7 @@ 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.
      */
@@ -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,6 +162,7 @@ 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.
      */
@@ -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

@@ -1,6 +1,5 @@
 package org.nwapw.abacus.plugin;
 
-import org.nwapw.abacus.Abacus;
 import org.nwapw.abacus.function.Function;
 import org.nwapw.abacus.function.Operator;
 import org.nwapw.abacus.number.NumberInterface;
@@ -53,17 +52,11 @@ public class PluginManager {
      * The list of plugin listeners attached to this instance.
      */
     private Set<PluginListener> listeners;
-    /**
-     * The instance of Abacus that is used to interact with its other
-     * components.
-     */
-    private Abacus abacus;
 
     /**
      * Creates a new plugin manager.
      */
-    public PluginManager(Abacus abacus){
+    public PluginManager() {
-        this.abacus = abacus;
         loadedPluginClasses = new HashSet<>();
         plugins = new HashSet<>();
         cachedFunctions = new HashMap<>();
@@ -80,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
@@ -105,8 +99,10 @@ 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.
      */
@@ -116,6 +112,7 @@ public class PluginManager {
 
     /**
      * Gets an operator under the given name.
+     *
      * @param name the name of the operator.
      * @return the operator under the given name.
      */
@@ -125,6 +122,7 @@ public class PluginManager {
 
     /**
      * Gets a numer implementation under the given name.
+     *
      * @param name the name of the implementation.
      * @return the implementation class
      */
@@ -134,6 +132,7 @@ public class PluginManager {
 
     /**
      * Adds an instance of Plugin that already has been instantiated.
+     *
      * @param plugin the plugin to add.
      */
     public void addInstantiated(Plugin plugin) {
@@ -145,6 +144,7 @@ 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) {
@@ -190,6 +190,7 @@ public class PluginManager {
 
     /**
      * Gets all the functions loaded by the Plugin Manager.
+     *
      * @return the set of all functions that were loaded.
      */
     public Set<String> getAllFunctions() {
@@ -198,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() {
@@ -206,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() {
@@ -214,6 +217,7 @@ public class PluginManager {
 
     /**
      * Adds a plugin change listener to this plugin manager.
+     *
      * @param listener the listener to add.
      */
     public void addListener(PluginListener listener) {
@@ -222,6 +226,7 @@ public class PluginManager {
 
     /**
      * Remove the plugin change listener from this plugin manager.
+     *
      * @param listener the listener to remove.
      */
     public void removeListener(PluginListener listener) {

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

@@ -0,0 +1,342 @@
+package org.nwapw.abacus.plugin;
+
+import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
+import org.nwapw.abacus.number.NaiveNumber;
+import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.number.PreciseNumber;
+
+import java.util.function.BiFunction;
+
+/**
+ * The plugin providing standard functions such as addition and subtraction to
+ * the calculator.
+ */
+public class StandardPlugin extends Plugin {
+
+    /**
+     * The addition operator, +
+     */
+    public static final Operator OP_ADD = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length >= 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface sum = params[0];
+            for (int i = 1; i < params.length; i++) {
+                sum = sum.add(params[i]);
+            }
+            return sum;
+        }
+    });
+    /**
+     * The subtraction operator, -
+     */
+    public static final Operator OP_SUBTRACT = new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 2;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return params[0].subtract(params[1]);
+        }
+    });
+    /**
+     * The multiplication operator, *
+     */
+    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;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface product = params[0];
+            for (int i = 1; i < params.length; i++) {
+                product = product.multiply(params[i]);
+            }
+            return product;
+        }
+    });
+    /**
+     * The division operator, /
+     */
+    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;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface product = params[0];
+            for (int i = 1; i < params.length; i++) {
+                product = product.multiply(params[i]);
+            }
+            return product;
+        }
+    });
+    /**
+     * The factorial operator, !
+     */
+    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
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            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) {
+                factorial = factorial.multiply(multiplier);
+            }
+            return factorial;
+                /*if(!storedList.containsKey(params[0].getClass())){
+                    storedList.put(params[0].getClass(), new ArrayList<NumberInterface>());
+                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
+                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
+                }*/
+        }
+    });
+    /**
+     * The caret / pow operator, ^
+     */
+    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]));
+        }
+    });
+    /**
+     * The absolute value function, abs(-3) = 3
+     */
+    public static final Function FUNCTION_ABS = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return params[0].multiply((new NaiveNumber(params[0].signum())).promoteTo(params[0].getClass()));
+        }
+    };
+    /**
+     * The exponential function, exp(1) = e^1 = 2.71...
+     */
+    public static final Function FUNCTION_EXP = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            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) {
+                sum = NaiveNumber.ONE.promoteTo(sum.getClass()).divide(sum);
+            }
+            return sum;
+        }
+    };
+    /**
+     * The natural log function, ln(exp(1)) = 1
+     */
+    public static final Function FUNCTION_LN = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface param = params[0];
+            int powersOf2 = 0;
+            while (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) {
+                    param = param.divide(new NaiveNumber(2).promoteTo(param.getClass()));
+                    powersOf2++;
+                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                        break;
+                        //No infinite loop for you.
+                    }
+                } else {
+                    param = param.multiply(new NaiveNumber(2).promoteTo(param.getClass()));
+                    powersOf2--;
+                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                        break;
+                        //No infinite loop for you.
+                    }
+                }
+            }
+            return getLog2(param).multiply((new NaiveNumber(powersOf2)).promoteTo(param.getClass())).add(getLogPartialSum(param));
+        }
+
+        /**
+         * Returns the partial sum of the Taylor series for logx (around x=1).
+         * Automatically determines the number of terms needed based on the precision of x.
+         * @param x value at which the series is evaluated. 0 < x < 2. (x=2 is convergent but impractical.)
+         * @return the partial sum.
+         */
+        private NumberInterface getLogPartialSum(NumberInterface x) {
+            NumberInterface maxError = getMaxError(x);
+            x = x.subtract(NaiveNumber.ONE.promoteTo(x.getClass())); //Terms used are for log(x+1).
+            NumberInterface currentNumerator = x, currentTerm = x, sum = x;
+            int n = 1;
+            while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0) {
+                n++;
+                currentNumerator = currentNumerator.multiply(x).negate();
+                currentTerm = currentNumerator.divide(new NaiveNumber(n).promoteTo(x.getClass()));
+                sum = sum.add(currentTerm);
+            }
+            return sum;
+        }
+
+        /**
+         * Returns natural log of 2 to the required precision of the class of number.
+         * @param number a number of the same type as the return type. (Used for precision.)
+         * @return the value of log(2) with the appropriate precision.
+         */
+        private NumberInterface getLog2(NumberInterface number) {
+            NumberInterface maxError = getMaxError(number);
+            //NumberInterface errorBound = (new NaiveNumber(1)).promoteTo(number.getClass());
+            //We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
+            //In the following, a=1/3^n, b=1/4^n, c = 1/n.
+            //a is also an error bound.
+            NumberInterface a = (new NaiveNumber(1)).promoteTo(number.getClass()), b = a, c = a;
+            NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClass());
+            int n = 0;
+            while (a.compareTo(maxError) >= 1) {
+                n++;
+                a = a.divide((new NaiveNumber(3)).promoteTo(number.getClass()));
+                b = b.divide((new NaiveNumber(4)).promoteTo(number.getClass()));
+                c = NaiveNumber.ONE.promoteTo(number.getClass()).divide((new NaiveNumber(n)).promoteTo(number.getClass()));
+                sum = sum.add(a.add(b).multiply(c));
+            }
+            return sum;
+        }
+    };
+    /**
+     * The square root function, sqrt(4) = 2
+     */
+    public static final Function FUNCTION_SQRT = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return OP_CARET.getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
+        }
+    };
+
+    public StandardPlugin(PluginManager manager) {
+        super(manager);
+    }
+
+    /**
+     * 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) {
+        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 evaluate the exponential function.
+     */
+    private static int getNTermsExp(NumberInterface maxError, NumberInterface x) {
+        //We need n such that |x^(n+1)| <= (n+1)! * maxError
+        //The variables LHS and RHS refer to the above inequality.
+        int n = 0;
+        x = FUNCTION_ABS.apply(x);
+        NumberInterface LHS = x, RHS = maxError;
+        while (LHS.compareTo(RHS) > 0) {
+            n++;
+            LHS = LHS.multiply(x);
+            RHS = RHS.multiply(new NaiveNumber(n + 1).promoteTo(RHS.getClass()));
+        }
+        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) {
+        NumberInterface sum = NaiveNumber.ZERO.promoteTo(x.getClass());
+        for (int i = 0; i <= n; i++) {
+            sum = sum.add(nthTermFunction.apply(i, x));
+        }
+        return sum;
+    }
+
+    /**
+     * 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) {
+        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

@@ -1,5 +1,7 @@
 package org.nwapw.abacus.tree;
 
+import org.nwapw.abacus.Abacus;
+
 /**
  * A tree node that represents an operation being applied to two operands.
  */
@@ -17,33 +19,39 @@ public class BinaryInfixNode extends TreeNode {
      * The right node of the operation.
      */
     private TreeNode right;
+    private Abacus trace;
 
-    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,Abacus trace) {
-        this(operation, null, null);
+        this(operation, null, null,trace);
     }
 
     /**
      * 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,Abacus trace) {
         this.operation = operation;
         this.left = left;
         this.right = right;
+        this.trace = trace;
     }
 
     /**
      * Gets the operation in this node.
+     *
      * @return the operation in this node.
      */
     public String getOperation() {
@@ -52,6 +60,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Gets the left sub-expression of this node.
+     *
      * @return the left node.
      */
     public TreeNode getLeft() {
@@ -60,6 +69,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 +78,7 @@ public class BinaryInfixNode extends TreeNode {
 
     /**
      * Gets the right sub-expression of this node.
+     *
      * @return the right node.
      */
     public TreeNode getRight() {
@@ -76,6 +87,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) {
@@ -84,11 +96,16 @@ public class BinaryInfixNode extends TreeNode {
 
     @Override
     public <T> T reduce(Reducer<T> reducer) {
+        if(!trace.getStop()) {
             T leftReduce = left.reduce(reducer);
+
             T rightReduce = right.reduce(reducer);
             if (leftReduce == null || rightReduce == null) return null;
             return reducer.reduceNode(this, leftReduce, rightReduce);
         }
+        return null;
+
+    }
 
     @Override
     public String toString() {

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

@@ -1,5 +1,7 @@
 package org.nwapw.abacus.tree;
 
+import org.nwapw.abacus.Abacus;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -16,23 +18,28 @@ public class FunctionNode extends TreeNode {
      * The list of arguments to the function.
      */
     private List<TreeNode> children;
+    private Abacus trace;
 
     /**
      * 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,Abacus trace) {
         this.function = function;
         children = new ArrayList<>();
+        this.trace = trace;
     }
 
     /**
      * Gets the function name for this node.
+     *
      * @return the function name.
      */
     public String getFunction() {
@@ -41,6 +48,7 @@ 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) {
@@ -49,6 +57,7 @@ public class FunctionNode extends TreeNode {
 
     /**
      * Adds a new child to the beginning of this node's child list.
+     *
      * @param node the node to add.
      */
     public void prependChild(TreeNode node) {

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;
 
 /**
@@ -22,6 +21,7 @@ public class NumberNode extends TreeNode {
 
     /**
      * 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) {
@@ -30,6 +30,7 @@ public class NumberNode extends TreeNode {
 
     /**
      * 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,6 +17,7 @@ public class NumberReducer implements Reducer<NumberInterface> {
 
     /**
      * Creates a new number reducer.
+     *
      * @param abacus the calculator instance.
      */
     public NumberReducer(Abacus abacus) {

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

@@ -2,12 +2,14 @@ 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.

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

@@ -16,6 +16,7 @@ public enum TokenType {
 
     /**
      * Creates a new token type with the given priority.
+     *
      * @param priority the priority of this token type.
      */
     TokenType(int 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

@@ -1,5 +1,7 @@
 package org.nwapw.abacus.tree;
 
+import org.nwapw.abacus.Abacus;
+
 public class UnaryPrefixNode extends TreeNode {
 
     /**
@@ -10,34 +12,42 @@ public class UnaryPrefixNode extends TreeNode {
      * The tree node to apply the operation to.
      */
     private TreeNode applyTo;
+    private Abacus trace;
 
     /**
      * 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,Abacus trace) {
-        this(operation, null);
+        this(operation, null,trace);
     }
 
     /**
      * 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,Abacus trace) {
         this.operation = operation;
         this.applyTo = applyTo;
+        this.trace = trace;
     }
 
     @Override
     public <T> T reduce(Reducer<T> reducer) {
+        if(!trace.getStop()) {
             Object reducedChild = applyTo.reduce(reducer);
             if (reducedChild == null) return null;
             return reducer.reduceNode(this, reducedChild);
         }
+        return null;
+    }
 
     /**
      * Gets the operation of this node.
+     *
      * @return the operation this node performs.
      */
     public String getOperation() {
@@ -46,6 +56,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,6 +43,7 @@ public class HistoryTableModel extends AbstractTableModel {
 
     /**
      * Adds an entry to the model.
+     *
      * @param entry the entry to add.
      */
     public void addEntry(HistoryEntry 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

@@ -16,12 +16,13 @@ import java.awt.event.MouseEvent;
  */
 public class Window extends JFrame {
     
+
     private static final String CALC_STRING = "Calculate";
     private static final String SYNTAX_ERR_STRING = "Syntax Error";
     private static final String EVAL_ERR_STRING = "Evaluation Error";
     private static final String NUMBER_SYSTEM_LABEL = "Number Type:";
     private static final String FUNCTION_LABEL = "Functions:";
-
+    private static final String STOP_STRING = "Stop";
     /**
      * Array of Strings to which the "calculate" button's text
      * changes. For instance, in the graph tab, the name will
@@ -90,7 +91,10 @@ public class Window extends JFrame {
      * The "submit" button.
      */
     private JButton inputEnterButton;
-
+    /**
+     * The stop calculations button.
+     */
+    private JButton inputStopButton;
     /**
      * The side panel for separate configuration.
      */
@@ -113,26 +117,80 @@ public class Window extends JFrame {
      * The list of functions available to the user.
      */
     private JComboBox<String> functionList;
+    /**
+     * Thread used for calculations
+     */
+    private Thread calculateThread;
+    /**
+     * Check if currently calculating.
+     */
+    private boolean calculating;
+    /**
+     * Checks if thread should stop calculating.
+     */
+    private boolean stopCalculating;
+    /**
+     * Test variable to check number of threads running in the calculator.
+     */
+    private int count;
+    /**
+     * ActionListener that stops calculations.
+     */
+    private ActionListener stopListener = (event) -> {
+        //System.out.println(count++);  //Shows about how many calculation threads are running with the calculating=false command
+        //calculating = false;          //Ignores result of calculation and allows for the start of a new calculation
+        stopCalculating = true;         //Stops calculation at the next node check
+        //calculateThread.stop();         //Stops thread no matter what, Unsafe
+    };
 
     /**
-     * Action listener that causes the input to be evaluated.
+     * Node check to get whether nodes should continue calculating.
+     * @return boolean stop calculations if true.
+     */
+    public boolean getStop(){
+        return stopCalculating;
+    }
+
+    /**
+     * ActionListener that runs all calculations.
      */
     private ActionListener evaluateListener = (event) -> {
-        TreeNode parsedExpression = abacus.parseString(inputField.getText());
+        Runnable calculate = new Runnable() {
+            public void run() {
+                boolean skip = false;
+                calculating = true;
+                TreeNode parsedExpression = null;
+                parsedExpression = abacus.parseString(inputField.getText());
                 if (parsedExpression == null) {
                     lastOutputArea.setText(SYNTAX_ERR_STRING);
-            return;
+                    skip = true;
                 }
+                if(!skip){
                     NumberInterface numberInterface = abacus.evaluateTree(parsedExpression);
                     if (numberInterface == null) {
                         lastOutputArea.setText(EVAL_ERR_STRING);
+                        calculating = false;
+                        stopCalculating = false;
+
                         return;
                     }
+                    if(calculateThread.equals(Thread.currentThread())) {
                         lastOutput = numberInterface.toString();
                         historyModel.addEntry(new HistoryTableModel.HistoryEntry(inputField.getText(), parsedExpression, lastOutput));
                         historyTable.invalidate();
                         lastOutputArea.setText(lastOutput);
                         inputField.setText("");
+                        calculating = false;
+                        stopCalculating = false;
+                    }
+                }
+            }
+        };
+        if(!calculating) {
+            calculateThread = new Thread(calculate);
+            calculateThread.setName("a-"+System.currentTimeMillis());
+            calculateThread.start();
+        }
     };
 
     /**
@@ -143,14 +201,24 @@ public class Window extends JFrame {
             evaluateListener,
             null
     };
+    /**
+     * Array of listeners that tell the stop button how to behave
+     * at a given input tab.
+     */
+    private ActionListener[] stopListeners = {
+            stopListener,
+            null
+    };
 
     /**
      * Creates a new window with the given manager.
+     *
      * @param abacus the calculator instance to interact with other components.
      */
     public Window(Abacus abacus) {
         this();
         this.abacus = abacus;
+        abacus.setWindow(this);
     }
 
     /**
@@ -159,25 +227,36 @@ public class Window extends JFrame {
     private Window() {
         super();
 
+        //variables related to when calculations occur
+        stopCalculating = false;
+        calculating = true;
+
         lastOutput = "";
 
+        //default window properties
         setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
         setSize(320, 480);
 
+        //initiates input objects
         inputField = new JTextField();
         inputEnterButton = new JButton(CALC_STRING);
+        inputStopButton = new JButton(STOP_STRING);
 
+        //adds input objects into Panel
         inputPanel = new JPanel();
         inputPanel.setLayout(new BorderLayout());
-        inputPanel.add(inputField, BorderLayout.CENTER);
+        inputPanel.add(inputStopButton, BorderLayout.SOUTH);
-        inputPanel.add(inputEnterButton, BorderLayout.SOUTH);
+        inputPanel.add(inputField, BorderLayout.NORTH);
+        inputPanel.add(inputEnterButton, BorderLayout.CENTER);
 
+        //initiates output objects in calculator tab
         historyModel = new HistoryTableModel();
         historyTable = new JTable(historyModel);
         historyScroll = new JScrollPane(historyTable);
         lastOutputArea = new JTextArea(lastOutput);
         lastOutputArea.setEditable(false);
 
+        //adds output objects into Panel
         calculationPanel = new JPanel();
         calculationPanel.setLayout(new BorderLayout());
         calculationPanel.add(historyScroll, BorderLayout.CENTER);
@@ -207,6 +286,8 @@ public class Window extends JFrame {
         settingsPanel.add(numberSystemPanel);
         settingsPanel.add(functionSelectPanel);
 
+        calculating = false;
+
         pane = new JTabbedPane();
         pane.add("Calculator", calculationPanel);
         pane.add("Settings", settingsPanel);
@@ -214,17 +295,23 @@ public class Window extends JFrame {
             int selectionIndex = pane.getSelectedIndex();
             boolean enabled = INPUT_ENABLED[selectionIndex];
             ActionListener listener = listeners[selectionIndex];
+            ActionListener stopUsed = stopListeners[selectionIndex];
             inputEnterButton.setText(BUTTON_NAMES[selectionIndex]);
             inputField.setEnabled(enabled);
             inputEnterButton.setEnabled(enabled);
+            inputStopButton.setEnabled(enabled);
 
             for (ActionListener removingListener : inputEnterButton.getActionListeners()) {
                 inputEnterButton.removeActionListener(removingListener);
                 inputField.removeActionListener(removingListener);
             }
+            for(ActionListener removingListener : inputStopButton.getActionListeners()){
+                inputStopButton.removeActionListener(removingListener);
+            }
             if (listener != null) {
                 inputEnterButton.addActionListener(listener);
                 inputField.addActionListener(listener);
+                inputStopButton.addActionListener(stopUsed);
             }
         });
         add(pane, BorderLayout.CENTER);
@@ -232,6 +319,7 @@ public class Window extends JFrame {
 
         inputEnterButton.addActionListener(evaluateListener);
         inputField.addActionListener(evaluateListener);
+        inputStopButton.addActionListener(stopListener);
         historyTable.addMouseListener(new MouseAdapter() {
             @Override
             public void mouseClicked(MouseEvent e) {
@@ -246,4 +334,9 @@ public class Window extends JFrame {
         });
     }
 
+    @Override
+    public void setVisible(boolean b) {
+        super.setVisible(b);
+        if(b) inputField.requestFocusInWindow();
+    }
 }

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

@@ -1,23 +0,0 @@
-package org.nwapw.abacus.parsing;
-
-import org.nwapw.abacus.tree.TreeNode;
-
-import java.util.List;
-
-public class TreeBuilder<T> {
-
-    private Tokenizer<T> tokenizer;
-    private Parser<T> parser;
-
-    public TreeBuilder(Tokenizer<T> tokenizer, Parser<T> parser){
-        this.tokenizer = tokenizer;
-        this.parser = parser;
-    }
-
-    public TreeNode fromString(String input){
-        List<T> tokens = tokenizer.tokenizeString(input);
-        if(tokens == null) return null;
-        return parser.constructTree(tokens);
-    }
-
-}

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

@@ -1,302 +0,0 @@
-package org.nwapw.abacus.plugin;
-
-import org.nwapw.abacus.function.Function;
-import org.nwapw.abacus.function.Operator;
-import org.nwapw.abacus.function.OperatorAssociativity;
-import org.nwapw.abacus.function.OperatorType;
-import org.nwapw.abacus.number.NaiveNumber;
-import org.nwapw.abacus.number.NumberInterface;
-import org.nwapw.abacus.number.PreciseNumber;
-
-import java.util.function.BiFunction;
-
-/**
- * The plugin providing standard functions such as addition and subtraction to
- * the calculator.
- */
-public class StandardPlugin extends Plugin {
-
-    public StandardPlugin(PluginManager manager) {
-        super(manager);
-    }
-
-    @Override
-    public void onEnable() {
-        registerNumber("naive", NaiveNumber.class);
-        registerNumber("precise", PreciseNumber.class);
-
-        registerOperator("+", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length >= 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                NumberInterface sum = params[0];
-                for(int i = 1; i < params.length; i++){
-                    sum = sum.add(params[i]);
-                }
-                return sum;
-            }
-        }));
-
-        registerOperator("-", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX, 0, new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 2;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                return params[0].subtract(params[1]);
-            }
-        }));
-
-        registerOperator("*", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length >= 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                NumberInterface product = params[0];
-                for(int i = 1; i < params.length; i++){
-                    product = product.multiply(params[i]);
-                }
-                return product;
-            }
-        }));
-
-        registerOperator("/", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,1, new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 2;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                return params[0].divide(params[1]);
-            }
-        }));
-
-        registerOperator("^", 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 StandardPlugin.this.getFunction("exp").apply(StandardPlugin.this.getFunction("ln").apply(params[0]).multiply(params[1]));
-            }
-        }));
-
-        registerOperator("!", 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
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                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){
-                    factorial = factorial.multiply(multiplier);
-                }
-                return factorial;
-                /*if(!storedList.containsKey(params[0].getClass())){
-                    storedList.put(params[0].getClass(), new ArrayList<NumberInterface>());
-                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
-                    storedList.get(params[0].getClass()).add(NaiveNumber.ONE.promoteTo(params[0].getClass()));
-                }*/
-            }
-        }));
-
-        registerFunction("abs", new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                return params[0].multiply((new NaiveNumber(params[0].signum())).promoteTo(params[0].getClass()));
-            }
-        });
-
-        registerFunction("exp", new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                boolean takeReciprocal = params[0].signum() == -1;
-                params[0] = StandardPlugin.this.getFunction("abs").apply(params[0]);
-                NumberInterface sum = sumSeries(params[0], StandardPlugin.this::getExpSeriesTerm, getNTermsExp(getMaxError(params[0]), params[0]));
-                if(takeReciprocal){
-                    sum = NaiveNumber.ONE.promoteTo(sum.getClass()).divide(sum);
-                }
-                return sum;
-            }
-        });
-
-        registerFunction("ln", new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                NumberInterface param = params[0];
-                int powersOf2 = 0;
-                while(StandardPlugin.this.getFunction("abs").apply(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass()))).compareTo((new NaiveNumber(0.1)).promoteTo(param.getClass())) >= 0){
-                    if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() == 1) {
-                        param = param.divide(new NaiveNumber(2).promoteTo(param.getClass()));
-                        powersOf2++;
-                        if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
-                            break;
-                            //No infinite loop for you.
-                        }
-                    }
-                    else {
-                        param = param.multiply(new NaiveNumber(2).promoteTo(param.getClass()));
-                        powersOf2--;
-                        if(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
-                            break;
-                            //No infinite loop for you.
-                        }
-                    }
-                }
-                return getLog2(param).multiply((new NaiveNumber(powersOf2)).promoteTo(param.getClass())).add(getLogPartialSum(param));
-            }
-
-            /**
-             * Returns the partial sum of the Taylor series for logx (around x=1).
-             * Automatically determines the number of terms needed based on the precision of x.
-             * @param x value at which the series is evaluated. 0 < x < 2. (x=2 is convergent but impractical.)
-             * @return the partial sum.
-             */
-            private NumberInterface getLogPartialSum(NumberInterface x){
-                NumberInterface maxError = StandardPlugin.this.getMaxError(x);
-                x = x.subtract(NaiveNumber.ONE.promoteTo(x.getClass())); //Terms used are for log(x+1).
-                NumberInterface currentTerm = x, sum = x;
-                int n = 1;
-                while(StandardPlugin.this.getFunction("abs").apply(currentTerm).compareTo(maxError) > 0){
-                    n++;
-                    currentTerm = currentTerm.multiply(x).multiply((new NaiveNumber(n-1)).promoteTo(x.getClass())).divide((new NaiveNumber(n)).promoteTo(x.getClass())).negate();
-                    sum = sum.add(currentTerm);
-                }
-                return sum;
-            }
-
-            /**
-             * Returns natural log of 2 to the required precision of the class of number.
-             * @param number a number of the same type as the return type. (Used for precision.)
-             * @return the value of log(2) with the appropriate precision.
-             */
-            private NumberInterface getLog2(NumberInterface number){
-                NumberInterface maxError = StandardPlugin.this.getMaxError(number);
-                //NumberInterface errorBound = (new NaiveNumber(1)).promoteTo(number.getClass());
-                //We'll use the series \sigma_{n >= 1) ((1/3^n + 1/4^n) * 1/n)
-                //In the following, a=1/3^n, b=1/4^n, c = 1/n.
-                //a is also an error bound.
-                NumberInterface a = (new NaiveNumber(1)).promoteTo(number.getClass()), b = a, c = a;
-                NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClass());
-                int n = 0;
-                while(a.compareTo(maxError) >= 1){
-                    n++;
-                    a = a.divide((new NaiveNumber(3)).promoteTo(number.getClass()));
-                    b = b.divide((new NaiveNumber(4)).promoteTo(number.getClass()));
-                    c = NaiveNumber.ONE.promoteTo(number.getClass()).divide((new NaiveNumber(n)).promoteTo(number.getClass()));
-                    sum = sum.add(a.add(b).multiply(c));
-                }
-                return sum;
-            }
-        });
-
-        registerFunction("sqrt", new Function() {
-            @Override
-            protected boolean matchesParams(NumberInterface[] params) {
-                return params.length == 1;
-            }
-
-            @Override
-            protected NumberInterface applyInternal(NumberInterface[] params) {
-                return StandardPlugin.this.getOperator("^").getFunction().apply(params[0], ((new NaiveNumber(0.5)).promoteTo(params[0].getClass())));
-            }
-        });
-    }
-
-    @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 NumberInterface getExpSeriesTerm(int n, NumberInterface x){
-        return x.intPow(n).divide(this.getOperator("!").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.
-     */
-    private int getNTermsExp(NumberInterface maxError, NumberInterface x) {
-        //We need n such that |x^(n+1)| <= (n+1)! * maxError
-        //The variables LHS and RHS refer to the above inequality.
-        int n = 0;
-        x = this.getFunction("abs").apply(x);
-        NumberInterface LHS = x, RHS = maxError;
-        while (LHS.compareTo(RHS) > 0) {
-            n++;
-            LHS = LHS.multiply(x);
-            RHS = RHS.multiply(new NaiveNumber(n + 1).promoteTo(RHS.getClass()));
-        }
-        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 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++){
-            sum = sum.add(nthTermFunction.apply(i, x));
-        }
-        return sum;
-    }
-
-    /**
-     * 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 NumberInterface getMaxError(NumberInterface number){
-        return (new NaiveNumber(10)).promoteTo(number.getClass()).intPow(-number.getMaxPrecision());
-    }
-
-}

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

@@ -0,0 +1,133 @@
+package org.nwapw.abacus.tests;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.nwapw.abacus.lexing.Lexer;
+import org.nwapw.abacus.lexing.pattern.Match;
+
+import java.util.List;
+
+public class LexerTests {
+
+    @Test
+    public void testBasicSuccess() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("abc", 0);
+        lexer.register("def", 1);
+        List<Match<Integer>> matchedIntegers = lexer.lexAll("abcdefabc", 0, Integer::compare);
+        Assert.assertNotNull(matchedIntegers);
+        Assert.assertEquals(matchedIntegers.get(0).getType(), Integer.valueOf(0));
+        Assert.assertEquals(matchedIntegers.get(1).getType(), Integer.valueOf(1));
+        Assert.assertEquals(matchedIntegers.get(2).getType(), Integer.valueOf(0));
+    }
+
+    @Test
+    public void testBasicFailure() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("abc", 0);
+        lexer.register("def", 1);
+        Assert.assertNull(lexer.lexAll("abcdefabcz", 0, Integer::compare));
+    }
+
+    @Test
+    public void testNoPatterns() {
+        Lexer<Integer> lexer = new Lexer<>();
+        Assert.assertNull(lexer.lexAll("abcdefabc", 0, Integer::compare));
+    }
+
+    @Test
+    public void testEmptyMatches() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a?", 0);
+        Assert.assertNull(lexer.lexAll("", 0, Integer::compare));
+    }
+
+    @Test
+    public void testOneOrMore() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a+", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+    }
+
+    @Test
+    public void testZeroOrMore() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a*", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+    }
+
+    @Test
+    public void testZeroOrOne() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a?", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 4);
+    }
+
+    @Test
+    public void testGreedyMatching() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("a*a", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+    }
+
+    @Test
+    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++) {
+            Assert.assertEquals(testString.substring(i, i + 1), tokens.get(i).getContent());
+        }
+    }
+
+    @Test
+    public void testBasicGroup() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("(abc)", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("abc", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+        Assert.assertEquals(tokens.get(0).getContent(), "abc");
+    }
+
+    @Test
+    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++) {
+            Assert.assertEquals(testString.substring(i, i + 1), tokens.get(i).getContent());
+        }
+    }
+
+    @Test
+    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() {
+        Lexer<Integer> lexer = new Lexer<>();
+        lexer.register("(abc)+", 0);
+        List<Match<Integer>> tokens = lexer.lexAll("abcabc", 0, Integer::compare);
+        Assert.assertNotNull(tokens);
+        Assert.assertEquals(tokens.size(), 1);
+    }
+
+}

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

@@ -0,0 +1,124 @@
+package org.nwapw.abacus.tests;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.nwapw.abacus.Abacus;
+import org.nwapw.abacus.function.Function;
+import org.nwapw.abacus.function.Operator;
+import org.nwapw.abacus.function.OperatorAssociativity;
+import org.nwapw.abacus.function.OperatorType;
+import org.nwapw.abacus.lexing.pattern.Match;
+import org.nwapw.abacus.number.NumberInterface;
+import org.nwapw.abacus.parsing.LexerTokenizer;
+import org.nwapw.abacus.plugin.Plugin;
+import org.nwapw.abacus.tree.TokenType;
+
+import java.util.List;
+
+public class TokenizerTests {
+
+    private static Abacus abacus = new Abacus();
+    private static LexerTokenizer lexerTokenizer = new LexerTokenizer();
+    private static Function subtractFunction = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 2;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            return params[0].subtract(params[1]);
+        }
+    };
+    private static Plugin testPlugin = new Plugin(abacus.getPluginManager()) {
+        @Override
+        public void onEnable() {
+            registerOperator("+", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
+                    0, subtractFunction));
+            registerOperator("-", new Operator(OperatorAssociativity.LEFT, OperatorType.BINARY_INFIX,
+                    0, subtractFunction));
+            registerFunction("subtract", subtractFunction);
+        }
+
+        @Override
+        public void onDisable() {
+
+        }
+    };
+
+    private static void assertTokensMatch(List<Match<TokenType>> tokenList, TokenType[] expectedTypes) {
+        Assert.assertNotNull(tokenList);
+        Assert.assertEquals(tokenList.size(), expectedTypes.length);
+        for (int i = 0; i < expectedTypes.length; i++) {
+            Assert.assertEquals(expectedTypes[i], tokenList.get(i).getType());
+        }
+    }
+
+    @BeforeClass
+    public static void prepareTests() {
+        abacus.getPluginManager().addListener(lexerTokenizer);
+        abacus.getPluginManager().addInstantiated(testPlugin);
+        abacus.getPluginManager().load();
+    }
+
+    @Test
+    public void testInteger() {
+        assertTokensMatch(lexerTokenizer.tokenizeString("11"), new TokenType[]{TokenType.NUM});
+    }
+
+    @Test
+    public void testLeadingZeroDecimal() {
+        assertTokensMatch(lexerTokenizer.tokenizeString("0.1"), new TokenType[]{TokenType.NUM});
+    }
+
+    @Test
+    public void testNonLeadingDecimal() {
+        assertTokensMatch(lexerTokenizer.tokenizeString(".1"), new TokenType[]{TokenType.NUM});
+    }
+
+    @Test
+    public void testSimpleChars() {
+        TokenType[] types = {
+                TokenType.OPEN_PARENTH,
+                TokenType.WHITESPACE,
+                TokenType.COMMA,
+                TokenType.CLOSE_PARENTH
+        };
+        assertTokensMatch(lexerTokenizer.tokenizeString("( ,)"), types);
+    }
+
+    @Test
+    public void testFunctionParsing() {
+        TokenType[] types = {
+                TokenType.FUNCTION,
+                TokenType.OPEN_PARENTH,
+                TokenType.NUM,
+                TokenType.COMMA,
+                TokenType.NUM,
+                TokenType.CLOSE_PARENTH
+        };
+        assertTokensMatch(lexerTokenizer.tokenizeString("subtract(1,2)"), types);
+    }
+
+    @Test
+    public void testOperatorParsing() {
+        TokenType[] types = {
+                TokenType.NUM,
+                TokenType.OP,
+                TokenType.NUM
+        };
+        assertTokensMatch(lexerTokenizer.tokenizeString("1-1"), types);
+    }
+
+    @Test
+    public void testSanitizedOperators() {
+        TokenType[] types = {
+                TokenType.NUM,
+                TokenType.OP,
+                TokenType.NUM
+        };
+        assertTokensMatch(lexerTokenizer.tokenizeString("1+1"), types);
+    }
+
+}