Add the list of number interface providers to Plugins.

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

@@ -1,7 +1,6 @@
 package org.nwapw.abacus;
 
 import org.nwapw.abacus.config.ConfigurationObject;
-import org.nwapw.abacus.fx.AbacusApplication;
 import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.parsing.LexerTokenizer;
@@ -12,7 +11,9 @@ import org.nwapw.abacus.plugin.PluginManager;
 import org.nwapw.abacus.plugin.StandardPlugin;
 import org.nwapw.abacus.tree.NumberReducer;
 import org.nwapw.abacus.tree.TreeNode;
+import org.nwapw.abacus.window.Window;
 
+import javax.swing.*;
 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
@@ -78,7 +79,13 @@ public class Abacus {
     }
 
     public static void main(String[] args) {
-        AbacusApplication.launch(AbacusApplication.class, args);
+        try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (ClassNotFoundException | InstantiationException | UnsupportedLookAndFeelException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+
+        new Window(new Abacus()).setVisible(true);
     }
 
     /**

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

@@ -1,20 +0,0 @@
-package org.nwapw.abacus.fx;
-
-import javafx.application.Application;
-import javafx.fxml.FXMLLoader;
-import javafx.scene.Parent;
-import javafx.scene.Scene;
-import javafx.stage.Stage;
-
-public class AbacusApplication extends Application {
-
-    @Override
-    public void start(Stage primaryStage) throws Exception {
-        Parent parent = FXMLLoader.load(getClass().getResource("/abacus.fxml"));
-        Scene mainScene = new Scene(parent, 320, 480);
-        primaryStage.setScene(mainScene);
-        primaryStage.setTitle("Abacus");
-        primaryStage.show();
-    }
-
-}

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

@@ -1,77 +0,0 @@
-package org.nwapw.abacus.fx;
-
-import javafx.collections.FXCollections;
-import javafx.collections.ObservableList;
-import javafx.fxml.FXML;
-import javafx.scene.control.*;
-import javafx.scene.text.Text;
-import javafx.util.Callback;
-import org.nwapw.abacus.Abacus;
-import org.nwapw.abacus.number.NumberInterface;
-import org.nwapw.abacus.tree.TreeNode;
-
-
-public class AbacusController {
-
-    private static final String ERR_SYNTAX = "Syntax Error";
-    private static final String ERR_EVAL = "Evaluation Error";
-
-    @FXML
-    private TableView<HistoryModel> historyTable;
-    @FXML
-    private TableColumn<HistoryModel, String> inputColumn;
-    @FXML
-    private TableColumn<HistoryModel, String> parsedColumn;
-    @FXML
-    private TableColumn<HistoryModel, String> outputColumn;
-    @FXML
-    private Text outputText;
-    @FXML
-    private TextField inputField;
-    @FXML
-    private Button inputButton;
-
-    private ObservableList<HistoryModel> historyData;
-
-    private Abacus abacus;
-
-    @FXML
-    public void initialize(){
-        Callback<TableColumn<HistoryModel, String>, TableCell<HistoryModel, String>> cellFactory =
-                param -> new CopyableCell<>();
-
-        abacus = new Abacus();
-        historyData = FXCollections.observableArrayList();
-        historyTable.setItems(historyData);
-        historyTable.getSelectionModel().setCellSelectionEnabled(true);
-        inputColumn.setCellFactory(cellFactory);
-        inputColumn.setCellValueFactory(cell -> cell.getValue().inputProperty());
-        parsedColumn.setCellFactory(cellFactory);
-        parsedColumn.setCellValueFactory(cell -> cell.getValue().parsedProperty());
-        outputColumn.setCellFactory(cellFactory);
-        outputColumn.setCellValueFactory(cell -> cell.getValue().outputProperty());
-    }
-
-    @FXML
-    private void performCalculation(){
-        inputButton.setDisable(true);
-        TreeNode constructedTree = abacus.parseString(inputField.getText());
-        if(constructedTree == null){
-            outputText.setText(ERR_SYNTAX);
-            inputButton.setDisable(false);
-            return;
-        }
-        NumberInterface evaluatedNumber = abacus.evaluateTree(constructedTree);
-        if(evaluatedNumber == null){
-            outputText.setText(ERR_EVAL);
-            inputButton.setDisable(false);
-            return;
-        }
-        outputText.setText(evaluatedNumber.toString());
-        historyData.add(new HistoryModel(inputField.getText(), constructedTree.toString(), evaluatedNumber.toString()));
-
-        inputButton.setDisable(false);
-        inputField.setText("");
-    }
-
-}

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

@@ -1,26 +0,0 @@
-package org.nwapw.abacus.fx;
-
-import javafx.scene.control.TableCell;
-import javafx.scene.input.MouseEvent;
-
-import java.awt.*;
-import java.awt.datatransfer.StringSelection;
-
-public class CopyableCell<S, T> extends TableCell<S, T> {
-
-    public CopyableCell(){
-        addEventFilter(MouseEvent.MOUSE_CLICKED, event -> {
-            if(event.getClickCount() == 2){
-                Toolkit.getDefaultToolkit().getSystemClipboard()
-                        .setContents(new StringSelection(getText()), null);
-            }
-        });
-    }
-
-    @Override
-    protected void updateItem(T item, boolean empty) {
-        super.updateItem(item, empty);
-        setText((empty || item == null) ? null : item.toString());
-        setGraphic(null);
-    }
-}

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

@@ -1,42 +0,0 @@
-package org.nwapw.abacus.fx;
-
-import javafx.beans.property.SimpleStringProperty;
-import javafx.beans.property.StringProperty;
-
-public class HistoryModel {
-
-    private final StringProperty input;
-    private final StringProperty parsed;
-    private final StringProperty output;
-
-    public HistoryModel(String input, String parsed, String output){
-        this.input = new SimpleStringProperty();
-        this.parsed = new SimpleStringProperty();
-        this.output = new SimpleStringProperty();
-        this.input.setValue(input);
-        this.parsed.setValue(parsed);
-        this.output.setValue(output);
-    }
-
-    public StringProperty inputProperty() {
-        return input;
-    }
-    public String getInput() {
-        return input.get();
-    }
-
-    public StringProperty parsedProperty() {
-        return parsed;
-    }
-    public String getParsed() {
-        return parsed.get();
-    }
-
-    public StringProperty outputProperty() {
-        return output;
-    }
-    public String getOutput() {
-        return output.get();
-    }
-
-}

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

@@ -93,6 +93,26 @@ public class NaiveNumber implements NumberInterface {
         return this.compareTo(ZERO);
     }
 
+    @Override
+    public NumberInterface ceiling() {
+        return new NaiveNumber(Math.ceil(value));
+    }
+
+    @Override
+    public NumberInterface floor() {
+        return new NaiveNumber(Math.floor(value));
+    }
+
+    @Override
+    public NumberInterface fractionalPart() {
+        return new NaiveNumber(value - Math.floor(value));
+    }
+
+    @Override
+    public int intValue() {
+        return (int)value;
+    }
+
     @Override
     public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
         if (toClass == this.getClass()) return this;

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

@@ -79,6 +79,31 @@ public interface NumberInterface {
      */
     int signum();
 
+    /**
+     * Returns the least integer greater than or equal to the number.
+     * @return the least integer >= the number, if int can hold the value.
+     */
+    NumberInterface ceiling();
+
+    /**
+     * Return the greatest integer less than or equal to the number.
+     * @return the greatest int >= the number, if int can hold the value.
+     */
+    NumberInterface floor();
+
+    /**
+     * Returns the fractional part of the number.
+     * @return the fractional part of the number.
+     */
+    NumberInterface fractionalPart();
+
+    /**
+     * Returns the integer representation of this number, discarding any fractional part,
+     * if int can hold the value.
+     * @return
+     */
+    int intValue();
+
     /**
      * Promotes this class to another number class.
      *

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

@@ -1,6 +1,7 @@
 package org.nwapw.abacus.number;
 
 import java.math.BigDecimal;
+import java.math.MathContext;
 import java.math.RoundingMode;
 
 public class PreciseNumber implements NumberInterface {
@@ -44,12 +45,12 @@ public class PreciseNumber implements NumberInterface {
 
     @Override
     public int getMaxPrecision() {
-        return 54;
+        return 65;
     }
 
     @Override
     public NumberInterface multiply(NumberInterface multiplier) {
-        return new PreciseNumber(value.multiply(((PreciseNumber) multiplier).value));
+        return new PreciseNumber(this.value.multiply(((PreciseNumber) multiplier).value));
     }
 
     @Override
@@ -94,6 +95,41 @@ public class PreciseNumber implements NumberInterface {
         return value.signum();
     }
 
+    @Override
+    public NumberInterface ceiling() {
+        String str = value.toPlainString();
+        int decimalIndex = str.indexOf('.');
+        if(decimalIndex != -1){
+            return this.floor().add(ONE);
+        }
+        return this;
+    }
+
+    @Override
+    public NumberInterface floor() {
+        String str = value.toPlainString();
+        int decimalIndex = str.indexOf('.');
+        if(decimalIndex != -1){
+            return new PreciseNumber(str.substring(0, decimalIndex));
+        }
+        return this;
+    }
+
+    @Override
+    public NumberInterface fractionalPart() {
+        String str = value.toPlainString();
+        int decimalIndex = str.indexOf('.');
+        if(decimalIndex != -1){
+            return new PreciseNumber(str.substring(decimalIndex + 1));
+        }
+        return ZERO;
+    }
+
+    @Override
+    public int intValue() {
+        return value.intValue();
+    }
+
     @Override
     public NumberInterface negate() {
         return new PreciseNumber(value.negate());
@@ -109,7 +145,7 @@ public class PreciseNumber implements NumberInterface {
 
     @Override
     public String toString() {
-        BigDecimal rounded = value.setScale(getMaxPrecision() - 4, RoundingMode.HALF_UP);
+        BigDecimal rounded = value.setScale(getMaxPrecision() - 15, RoundingMode.HALF_UP);
         return rounded.stripTrailingZeros().toPlainString();
     }
 }

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

@@ -29,6 +29,10 @@ public abstract class Plugin {
      * A hash map of operators mapped to their string names.
      */
     private Map<String, Class<? extends NumberInterface>> numbers;
+    /**
+     * A hash map of constant providers for each number type.
+     */
+    private Map<Class<?>, java.util.function.Function<String, NumberInterface>> constantProviders;
     /**
      * The plugin manager in which to search for functions
      * not inside this package,
@@ -52,6 +56,7 @@ public abstract class Plugin {
         functions = new HashMap<>();
         operators = new HashMap<>();
         numbers = new HashMap<>();
+        constantProviders = new HashMap<>();
         enabled = false;
     }
 
@@ -82,6 +87,14 @@ public abstract class Plugin {
         return numbers.keySet();
     }
 
+    /**
+     * Gets the list of all constant providers provided by this plugin.
+     * @return the list of constant providers.
+     */
+    public final Set<Class<?>> providedConstantProviders() {
+        return constantProviders.keySet();
+    }
+
     /**
      * Gets a function under the given function name.
      *
@@ -112,6 +125,16 @@ public abstract class Plugin {
         return numbers.get(numberName);
     }
 
+    /**
+     * Gets the constant provider for the given class.
+     *
+     * @param pluginClass the class for which to provide constants.
+     * @return the provider, or null, if the plugin doesn't provide it.
+     */
+    public final java.util.function.Function<String, NumberInterface> getConstantProvider(Class<?> pluginClass){
+        return constantProviders.get(pluginClass);
+    }
+
     /**
      * Enables the function, loading the necessary instances
      * of functions.
@@ -131,6 +154,8 @@ public abstract class Plugin {
         onDisable();
         functions.clear();
         operators.clear();
+        numbers.clear();
+        constantProviders.clear();
         enabled = false;
     }
 
@@ -170,6 +195,19 @@ public abstract class Plugin {
         numbers.put(name, toRegister);
     }
 
+    /**
+     * To be used in load(). Registers a constant provider
+     * with the plugin internally, which makes it possible
+     * for the calculations to look up constants for each different
+     * number type.
+     * @param providerFor the class the provider works with.
+     * @param constantProvider the provider to register.
+     */
+    protected final void registerConstantProvider(Class<?> providerFor,
+                                                   java.util.function.Function<String, NumberInterface> constantProvider) {
+        constantProviders.put(providerFor, constantProvider);
+    }
+
     /**
      * Searches the PluginManager for the given function name.
      * This can be used by the plugins internally in order to call functions
@@ -194,6 +232,30 @@ public abstract class Plugin {
         return manager.operatorFor(name);
     }
 
+    /**
+     * Searches the PluginManager for the given number implementation.
+     * This can be used by the plugins internally in order to
+     * find classes by name that they do not provide.
+     *
+     * @param name the name for which to search
+     * @return the resulting number class.
+     */
+    protected final Class<? extends NumberInterface> numberFor(String name) {
+        return manager.numberFor(name);
+    }
+
+    /**
+     * Searches the PluginManager for the given constant provider.
+     * This can be used by the plugins internally in order
+     * to find constant providers for number provider they do not provide.
+     *
+     * @param forClass the class for which to get a generator for.
+     * @return the resulting generator
+     */
+    protected final java.util.function.Function<String, NumberInterface> constantProviderFor(Class<?> forClass){
+        return manager.constantProviderFor(forClass);
+    }
+
     /**
      * Abstract method to be overridden by plugin implementation, in which the plugins
      * are supposed to register the functions they provide and do any other

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

@@ -36,6 +36,11 @@ public class PluginManager {
      * been cached, that is, found in a plugin and returned.
      */
     private Map<String, Class<? extends NumberInterface>> cachedNumbers;
+    /**
+     * List of registered constant providers for every
+     * number class.
+     */
+    private Map<Class<?>, java.util.function.Function<String, NumberInterface>> cachedConstantProviders;
     /**
      * List of all functions loaded by the plugins.
      */
@@ -48,6 +53,10 @@ public class PluginManager {
      * List of all numbers loaded by the plugins.
      */
     private Set<String> allNumbers;
+    /**
+     * List of all the constant providers loaded by the plugins.
+     */
+    private Set<Class<?>> allConstantProviders;
     /**
      * The list of plugin listeners attached to this instance.
      */
@@ -62,9 +71,11 @@ public class PluginManager {
         cachedFunctions = new HashMap<>();
         cachedOperators = new HashMap<>();
         cachedNumbers = new HashMap<>();
+        cachedConstantProviders = new HashMap<>();
         allFunctions = new HashSet<>();
         allOperators = new HashSet<>();
         allNumbers = new HashSet<>();
+        allConstantProviders = new HashSet<>();
         listeners = new HashSet<>();
     }
 
@@ -80,12 +91,13 @@ public class PluginManager {
      * @param getFunction the function to get the T value under the given name
      * @param name        the name to search for
      * @param <T>         the type of element being search
+     * @param <K>         the type of key that the cache is indexed by.
      * @return the retrieved element, or null if it was not found.
      */
-    private static <T> T searchCached(Collection<Plugin> plugins, Map<String, T> cache,
-                                      java.util.function.Function<Plugin, Set<String>> setFunction,
-                                      java.util.function.BiFunction<Plugin, String, T> getFunction,
-                                      String name) {
+    private static <T, K> T searchCached(Collection<Plugin> plugins, Map<K, T> cache,
+                                      java.util.function.Function<Plugin, Set<K>> setFunction,
+                                      java.util.function.BiFunction<Plugin, K, T> getFunction,
+                                      K name) {
         if (cache.containsKey(name)) return cache.get(name);
 
         T loadedValue = null;
@@ -130,6 +142,15 @@ public class PluginManager {
         return searchCached(plugins, cachedNumbers, Plugin::providedNumbers, Plugin::getNumber, name);
     }
 
+    /**
+     * Gets the constant provider for the given class.
+     * @param forClass the class to get the provider for.
+     * @return the provider.
+     */
+    public java.util.function.Function<String, NumberInterface> constantProviderFor(Class<?> forClass){
+        return searchCached(plugins, cachedConstantProviders, Plugin::providedConstantProviders, Plugin::getConstantProvider, forClass);
+    }
+
     /**
      * Adds an instance of Plugin that already has been instantiated.
      *
@@ -165,6 +186,7 @@ public class PluginManager {
             allFunctions.addAll(plugin.providedFunctions());
             allOperators.addAll(plugin.providedOperators());
             allNumbers.addAll(plugin.providedNumbers());
+            allConstantProviders.addAll(plugin.providedConstantProviders());
         }
         listeners.forEach(e -> e.onLoad(this));
     }
@@ -177,6 +199,7 @@ public class PluginManager {
         allFunctions.clear();
         allOperators.clear();
         allNumbers.clear();
+        allConstantProviders.clear();
         listeners.forEach(e -> e.onUnload(this));
     }
 
@@ -215,6 +238,14 @@ public class PluginManager {
         return allNumbers;
     }
 
+    /**
+     * Gets all the constant providers loaded by the Plugin Manager.
+     * @return the set of all constant providers that were loaded.
+     */
+    public Set<Class<?>> getAllConstantProviders() {
+        return allConstantProviders;
+    }
+
     /**
      * Adds a plugin change listener to this plugin manager.
      *

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

@@ -8,6 +8,9 @@ import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.number.PreciseNumber;
 
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.function.BiFunction;
 
 /**
@@ -16,6 +19,9 @@ import java.util.function.BiFunction;
  */
 public class StandardPlugin extends Plugin {
 
+    private static HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>> factorialLists = new HashMap<Class<? extends NumberInterface>, ArrayList<NumberInterface>>();
+    static HashMap<Class<? extends NumberInterface>, NumberInterface> piValues = new HashMap<Class<? extends NumberInterface>, NumberInterface>();
+
     /**
      * The addition operator, +
      */
@@ -152,17 +158,40 @@ public class StandardPlugin extends Plugin {
 
         @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);
+            NumberInterface maxError = getMaxError(params[0]);
+            int n = 0;
+            if(params[0].signum() <= 0){
+                NumberInterface currentTerm = NaiveNumber.ONE.promoteTo(params[0].getClass()), sum = currentTerm;
+                while(FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0){
+                    n++;
+                    currentTerm = currentTerm.multiply(params[0]).divide((new NaiveNumber(n)).promoteTo(params[0].getClass()));
+                    sum = sum.add(currentTerm);
+                }
+                return sum;
+            }
+            else{
+                //We need n such that x^(n+1) * 3^ceil(x) <= maxError * (n+1)!.
+                //right and left refer to lhs and rhs in the above inequality.
+                NumberInterface sum = NaiveNumber.ONE.promoteTo(params[0].getClass());
+                NumberInterface nextNumerator = params[0];
+                NumberInterface left = params[0].multiply((new NaiveNumber(3)).promoteTo(params[0].getClass()).intPow(params[0].ceiling().intValue())), right = maxError;
+                do{
+                    sum = sum.add(nextNumerator.divide(factorial(params[0].getClass(), n+1)));
+                    n++;
+                    nextNumerator = nextNumerator.multiply(params[0]);
+                    left = left.multiply(params[0]);
+                    NumberInterface nextN = (new NaiveNumber(n+1)).promoteTo(params[0].getClass());
+                    right = right.multiply(nextN);
+                    //System.out.println(left + ", " + right);
+                }
+                while(left.compareTo(right) > 0);
+                //System.out.println(n+1);
+                return sum;
             }
-            return sum;
         }
     };
     /**
-     * The natural log function, ln(exp(1)) = 1
+     * The natural log function.
      */
     public static final Function FUNCTION_LN = new Function() {
         @Override
@@ -203,11 +232,12 @@ public class StandardPlugin extends Plugin {
         private NumberInterface getLogPartialSum(NumberInterface x) {
             NumberInterface maxError = getMaxError(x);
             x = x.subtract(NaiveNumber.ONE.promoteTo(x.getClass())); //Terms used are for log(x+1).
-            NumberInterface currentTerm = x, sum = x;
+            NumberInterface currentNumerator = x, currentTerm = x, sum = x;
             int n = 1;
             while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0) {
                 n++;
-                currentTerm = currentTerm.multiply(x).multiply((new NaiveNumber(n - 1)).promoteTo(x.getClass())).divide((new NaiveNumber(n)).promoteTo(x.getClass())).negate();
+                currentNumerator = currentNumerator.multiply(x).negate();
+                currentTerm = currentNumerator.divide(new NaiveNumber(n).promoteTo(x.getClass()));
                 sum = sum.add(currentTerm);
             }
             return sum;
@@ -238,7 +268,7 @@ public class StandardPlugin extends Plugin {
         }
     };
     /**
-     * The square root function, sqrt(4) = 2
+     * The square root function.
      */
     public static final Function FUNCTION_SQRT = new Function() {
         @Override
@@ -252,43 +282,36 @@ public class StandardPlugin extends Plugin {
         }
     };
 
+    /**
+     * The sine function (the argument is interpreted in radians).
+     */
+    public static final Function FUNCTION_SIN = new Function() {
+        @Override
+        protected boolean matchesParams(NumberInterface[] params) {
+            return params.length == 1;
+        }
+
+        @Override
+        protected NumberInterface applyInternal(NumberInterface[] params) {
+            NumberInterface pi = getPi(params[0].getClass());
+            NumberInterface twoPi = pi.multiply(new NaiveNumber(2).promoteTo(pi.getClass()));
+            NumberInterface theta = getSmallAngle(params[0]);
+            //System.out.println(theta);
+            if(theta.compareTo(pi.multiply(new NaiveNumber(1.5).promoteTo(twoPi.getClass()))) >= 0){
+                theta = theta.subtract(twoPi);
+            }
+            else if(theta.compareTo(pi.divide(new NaiveNumber(2).promoteTo(pi.getClass()))) > 0){
+                theta = pi.subtract(theta);
+            }
+            //System.out.println(theta);
+            return sinTaylor(theta);
+        }
+    };
+
     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 evaluated 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.
      *
@@ -331,6 +354,7 @@ public class StandardPlugin extends Plugin {
         registerFunction("exp", FUNCTION_EXP);
         registerFunction("ln", FUNCTION_LN);
         registerFunction("sqrt", FUNCTION_SQRT);
+        registerFunction("sin", FUNCTION_SIN);
     }
 
     @Override
@@ -338,4 +362,93 @@ public class StandardPlugin extends Plugin {
 
     }
 
+    /**
+     * A factorial function that uses memoization for each number class; it efficiently
+     * computes factorials of non-negative integers.
+     * @param numberClass type of number to return.
+     * @param n non-negative integer.
+     * @return a number of numClass with value n factorial.
+     */
+    public static NumberInterface factorial(Class<? extends NumberInterface> numberClass, int n){
+        if(!factorialLists.containsKey(numberClass)){
+            factorialLists.put(numberClass, new ArrayList<NumberInterface>());
+            factorialLists.get(numberClass).add(NaiveNumber.ONE.promoteTo(numberClass));
+            factorialLists.get(numberClass).add(NaiveNumber.ONE.promoteTo(numberClass));
+        }
+        ArrayList<NumberInterface> list = factorialLists.get(numberClass);
+        if(n >= list.size()){
+            while(list.size() < n + 16){
+                list.add(list.get(list.size()-1).multiply(new NaiveNumber(list.size()).promoteTo(numberClass)));
+            }
+        }
+        return list.get(n);
+    }
+
+    /**
+     * Returns the value of the Taylor series for sin (centered at 0) at x.
+     * @param x where the series is evaluated.
+     * @return the value of the series
+     */
+    private static NumberInterface sinTaylor(NumberInterface x){
+        NumberInterface power = x, multiplier = x.multiply(x).negate(), currentTerm = x, sum = x;
+        NumberInterface maxError = getMaxError(x);
+        int n = 1;
+        do{
+            n += 2;
+            power = power.multiply(multiplier);
+            currentTerm = power.divide(factorial(x.getClass(), n));
+            sum = sum.add(currentTerm);
+        } while (FUNCTION_ABS.apply(currentTerm).compareTo(maxError) > 0);
+        return sum;
+    }
+
+    /**
+     * Returns an approximation of Pi, with appropriate accuracy for given number class.
+     * @param numClass type of number.
+     * @return A number of class numClass, with value approximately Pi = 3.1415...
+     */
+    public static NumberInterface getPi(Class<? extends NumberInterface> numClass){
+        if(!piValues.containsKey(numClass)){
+            //https://en.wikipedia.org/wiki/Chudnovsky_algorithm
+            NumberInterface C = FUNCTION_SQRT.apply(new NaiveNumber(10005).promoteTo(numClass)).multiply(new NaiveNumber(426880).promoteTo(numClass));
+            NumberInterface M = NaiveNumber.ONE.promoteTo(numClass);
+            NumberInterface L = new NaiveNumber(13591409).promoteTo(numClass);
+            NumberInterface X = M;
+            NumberInterface sum = L;
+            int termsNeeded = C.getMaxPrecision()/13 + 1;
+
+            NumberInterface lSummand = new NaiveNumber(545140134).promoteTo(L.getClass());
+            NumberInterface xMultiplier = new NaiveNumber(262537412).promoteTo(X.getClass())
+                    .multiply(new NaiveNumber(1000000000).promoteTo(X.getClass()))
+                    .add(new NaiveNumber(640768000).promoteTo(X.getClass()))
+                    .negate();
+            for(int i = 0; i < termsNeeded; i++){
+                M = M
+                        .multiply(new NaiveNumber(12*i+2).promoteTo(M.getClass()))
+                        .multiply(new NaiveNumber(12*i+6).promoteTo(M.getClass()))
+                        .multiply(new NaiveNumber(12*i+10).promoteTo(M.getClass()))
+                        .divide(new NaiveNumber(Math.pow(i+1,3)).promoteTo(M.getClass()));
+                L = L.add(lSummand);
+                X = X.multiply(xMultiplier);
+                sum = sum.add(M.multiply(L).divide(X));
+            }
+            piValues.put(numClass, C.divide(sum));
+        }
+        return piValues.get(numClass);
+    }
+
+    /**
+     * Returns an equivalent angle in the interval [0, 2pi)
+     * @param phi an angle (in radians).
+     * @return theta in [0, 2pi) that differs from phi by a multiple of 2pi.
+     */
+    private static NumberInterface getSmallAngle(NumberInterface phi){
+        NumberInterface twoPi = getPi(phi.getClass()).multiply(new NaiveNumber("2").promoteTo(phi.getClass()));
+        NumberInterface theta = FUNCTION_ABS.apply(phi).subtract(twoPi
+        .multiply(FUNCTION_ABS.apply(phi).divide(twoPi).floor())); //Now theta is in [0, 2pi).
+        if(phi.signum() < 0){
+            theta = twoPi.subtract(theta);
+        }
+        return theta;
+    }
 }

src/main/resources/abacus.fxml

@@ -1,46 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<?import javafx.geometry.Insets?>
-<?import javafx.scene.control.*?>
-<?import javafx.scene.layout.BorderPane?>
-<?import javafx.scene.layout.VBox?>
-<?import javafx.scene.text.Text?>
-<BorderPane xmlns="http://javafx.com/javafx"
-            xmlns:fx="http://javafx.com/fxml"
-            fx:controller="org.nwapw.abacus.fx.AbacusController">
-    <center>
-        <TabPane>
-            <Tab text="Calculator" closable="false">
-                <BorderPane>
-                    <center>
-                        <TableView fx:id="historyTable">
-                            <columnResizePolicy>
-                                <TableView fx:constant="CONSTRAINED_RESIZE_POLICY"/>
-                            </columnResizePolicy>
-                            <columns>
-                                <TableColumn fx:id="inputColumn" text="Input" sortable="false"/>
-                                <TableColumn fx:id="parsedColumn" text="Parsed" sortable="false"/>
-                                <TableColumn fx:id="outputColumn" text="Output" sortable="false"/>
-                            </columns>
-                        </TableView>
-                    </center>
-                    <bottom>
-                        <VBox>
-                            <ScrollPane prefHeight="50" vbarPolicy="NEVER">
-                                <padding>
-                                    <Insets top="10" bottom="10" left="10" right="10"/>
-                                </padding>
-                                <Text fx:id="outputText"/>
-                            </ScrollPane>
-                            <TextField fx:id="inputField" onAction="#performCalculation"/>
-                            <Button fx:id="inputButton" text="Calculate" maxWidth="Infinity"
-                                    onAction="#performCalculation"/>
-                        </VBox>
-                    </bottom>
-                </BorderPane>
-            </Tab>
-            <Tab text="Settings" closable="false"/>
-        </TabPane>
-    </center>
-
-</BorderPane>