Add a binary number type based on the naive number.

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

@@ -6,6 +6,10 @@ import javafx.scene.Parent;
 import javafx.scene.Scene;
 import javafx.stage.Stage;
 
+/**
+ * The main application class for JavaFX responsible for loading
+ * and displaying the fxml file.
+ */
 public class AbacusApplication extends Application {
 
     @Override

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

@@ -11,9 +11,19 @@ import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.tree.TreeNode;
 
 
+/**
+ * The controller for the abacus FX UI, responsible
+ * for all the user interaction.
+ */
 public class AbacusController {
 
+    /**
+     * Constant string that is displayed if the text could not be lexed or parsed.
+     */
     private static final String ERR_SYNTAX = "Syntax Error";
+    /**
+     * Constant string that is displayed if the tree could not be reduced.
+     */
     private static final String ERR_EVAL = "Evaluation Error";
 
     @FXML
@@ -31,8 +41,15 @@ public class AbacusController {
     @FXML
     private Button inputButton;
 
+    /**
+     * The list of history entries, created by the users.
+     */
     private ObservableList<HistoryModel> historyData;
 
+    /**
+     * The abacus instance used for calculations and all
+     * other main processing code.
+     */
     private Abacus abacus;
 
     @FXML

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

@@ -6,8 +6,17 @@ import javafx.scene.input.MouseEvent;
 import java.awt.*;
 import java.awt.datatransfer.StringSelection;
 
+/**
+ * A cell that copies its value to the clipboard
+ * when double clicked.
+ * @param <S> The type of the table view generic type.
+ * @param <T> The type of the value contained in the cell.
+ */
 public class CopyableCell<S, T> extends TableCell<S, T> {
 
+    /**
+     * Creates a new copyable cell.
+     */
     public CopyableCell(){
         addEventFilter(MouseEvent.MOUSE_CLICKED, event -> {
             if(event.getClickCount() == 2){

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

@@ -3,12 +3,33 @@ package org.nwapw.abacus.fx;
 import javafx.beans.property.SimpleStringProperty;
 import javafx.beans.property.StringProperty;
 
+/**
+ * The data model used for storing history entries.
+ */
 public class HistoryModel {
 
+    /**
+     * The property used for displaying the column
+     * for the user input.
+     */
     private final StringProperty input;
+    /**
+     * The property used for displaying the column
+     * that contains the parsed input.
+     */
     private final StringProperty parsed;
+    /**
+     * The property used for displaying the column
+     * that contains the program output.
+     */
     private final StringProperty output;
 
+    /**
+     * Creates a new history model with the given variables.
+     * @param input the user input
+     * @param parsed the parsed input
+     * @param output the program output.
+     */
     public HistoryModel(String input, String parsed, String output){
         this.input = new SimpleStringProperty();
         this.parsed = new SimpleStringProperty();
@@ -18,23 +39,47 @@ public class HistoryModel {
         this.output.setValue(output);
     }
 
+    /**
+     * Gets the input property.
+     * @return the input property.
+     */
     public StringProperty inputProperty() {
         return input;
     }
+    /**
+     * Gets the input.
+     * @return the input.
+     */
     public String getInput() {
         return input.get();
     }
 
+    /**
+     * Gets the parsed input property.
+     * @return the parsed input property.
+     */
     public StringProperty parsedProperty() {
         return parsed;
     }
+    /**
+     * Gets the parsed input.
+     * @return the parsed input.
+     */
     public String getParsed() {
         return parsed.get();
     }
 
+    /**
+     * Gets the output property.
+     * @return the output property.
+     */
     public StringProperty outputProperty() {
         return output;
     }
+    /**
+     * Gets the program output.
+     * @return the output.
+     */
     public String getOutput() {
         return output.get();
     }

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

@@ -0,0 +1,162 @@
+package org.nwapw.abacus.number;
+
+public class BinaryNumber implements NumberInterface{
+
+    /**
+     * The number zero.
+     */
+    public static final BinaryNumber ZERO = new BinaryNumber(0);
+    /**
+     * The number one.
+     */
+    public static final BinaryNumber ONE = new BinaryNumber(1);
+    /**
+     * The value of this number.
+     */
+    private double value;
+
+    /**
+     * Creates a new BinaryNumber with the given string.
+     *
+     * @param value the value, which will be parsed as a double.
+     */
+    public BinaryNumber(String value) {
+        toStandard(value);
+    }
+    /**
+     * 
+     */
+    private void toStandard(String value) {
+        String before;
+        String after = "";
+        if(value.indexOf(".")==-1){
+            before=value;
+        }else{
+            before = value.substring(0,value.indexOf("."));
+            after = value.substring(value.indexOf(".")+1);
+        }
+        double sum = 0;
+        for(int it=0;before.length()>0;it++){
+            if(before.charAt(before.length()-1)=='1'){
+                sum+=Math.pow(2,it);
+            }
+            if(before.length()>1) {
+                before = before.substring(0, before.length()-1);
+            }else{
+                before = "";
+            }
+        }
+        for(int it=-1;after.length()>0;it--) {
+            if (after.charAt(0) == '1') {
+                sum += Math.pow(2, it);
+            }
+            if (after.length() > 1) {
+                after = after.substring(1);
+            } else {
+                after = "";
+            }
+        }
+
+        this.value = sum;
+    }
+    
+    /**
+     * Creates a new BinaryNumber with the given value.
+     *
+     * @param value the value to use.
+     */
+    public BinaryNumber(double value) {
+        toStandard(""+value);
+    }
+
+    @Override
+    public int getMaxPrecision() {
+        return 18;
+    }
+
+    @Override
+    public NumberInterface multiply(NumberInterface multiplier) {
+        return new BinaryNumber(value * ((BinaryNumber) multiplier).value);
+    }
+
+    @Override
+    public NumberInterface divide(NumberInterface divisor) {
+        return new BinaryNumber(value / ((BinaryNumber) divisor).value);
+    }
+
+    @Override
+    public NumberInterface add(NumberInterface summand) {
+        return new BinaryNumber(value + ((BinaryNumber) summand).value);
+    }
+
+    @Override
+    public NumberInterface subtract(NumberInterface subtrahend) {
+        return new BinaryNumber(value - ((BinaryNumber) subtrahend).value);
+    }
+
+    @Override
+    public NumberInterface negate() {
+        return new BinaryNumber(-value);
+    }
+
+    @Override
+    public NumberInterface intPow(int exponent) {
+        if (exponent == 0) {
+            return BinaryNumber.ONE;
+        }
+        boolean takeReciprocal = exponent < 0;
+        exponent = Math.abs(exponent);
+        NumberInterface power = this;
+        for (int currentExponent = 1; currentExponent < exponent; currentExponent++) {
+            power = power.multiply(this);
+        }
+        if (takeReciprocal) {
+            power = BinaryNumber.ONE.divide(power);
+        }
+        return power;
+    }
+
+    @Override
+    public int compareTo(NumberInterface number) {
+        BinaryNumber num = (BinaryNumber) number;
+        return Double.compare(value, num.value);
+    }
+
+    @Override
+    public int signum() {
+        return this.compareTo(ZERO);
+    }
+
+    @Override
+    public NumberInterface promoteTo(Class<? extends NumberInterface> toClass) {
+        if (toClass == this.getClass()) return this;
+        else if (toClass == PreciseNumber.class) {
+            return new PreciseNumber(Double.toString(value));
+        }
+        return null;
+    }
+
+    public String toString() {
+        double sum = 0;
+        double tempValue = Math.floor(value);
+        double fraction = value-tempValue;
+        for (int it=0;tempValue > 0;it++) {
+
+            if (tempValue % 2 == 1) {
+                sum+=Math.pow(10,it);
+                tempValue-=1;
+            }
+            tempValue=tempValue/2;
+        }
+        for (int it=0;fraction > 0;it--) {
+
+            if (fraction % 2 >= 1) {
+                sum+=Math.pow(10,it);
+                fraction-=1;
+            }
+            fraction=fraction*2;
+        }
+        double shiftBy = Math.pow(10, 10);
+        return Double.toString(Math.round(sum * shiftBy) / shiftBy);
+    }
+}

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

@@ -93,6 +93,11 @@ public class NaiveNumber implements NumberInterface {
         return this.compareTo(ZERO);
     }
 
+    @Override
+    public int ceiling() {
+        return (int) Math.ceil(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,12 @@ 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.
+     */
+    int ceiling();
+
     /**
      * Promotes this class to another number class.
      *

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

@@ -3,6 +3,10 @@ package org.nwapw.abacus.number;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 
+/**
+ * A number that uses a BigDecimal to store its value,
+ * leading to infinite possible precision.
+ */
 public class PreciseNumber implements NumberInterface {
 
     /**
@@ -44,12 +48,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 +98,11 @@ public class PreciseNumber implements NumberInterface {
         return value.signum();
     }
 
+    @Override
+    public int ceiling() {
+        return (int) Math.ceil(value.doubleValue());
+    }
+
     @Override
     public NumberInterface negate() {
         return new PreciseNumber(value.negate());
@@ -109,7 +118,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/StandardPlugin.java

@@ -8,6 +8,8 @@ import org.nwapw.abacus.number.NaiveNumber;
 import org.nwapw.abacus.number.NumberInterface;
 import org.nwapw.abacus.number.PreciseNumber;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.function.BiFunction;
 
 /**
@@ -16,6 +18,8 @@ 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>>();
+
     /**
      * The addition operator, +
      */
@@ -152,17 +156,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())), 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 +230,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 +266,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
@@ -256,39 +284,6 @@ public class StandardPlugin extends Plugin {
         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.
      *
@@ -338,4 +333,19 @@ public class StandardPlugin extends Plugin {
 
     }
 
+    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);
+    }
+
 }