Fix exp function

README.md

@@ -5,10 +5,10 @@ Summer project for NWAPW.
 Created by Arthur Drobot, Danila Fedorin and Riley Jones.
 
 ## Project Description
-Abacus is a calculator built with extensibility and usability in mind. It provides a plugin interface, via Java, as Lua provides too difficult to link up to the Java core. The description of the internals of the project can be found on the wiki page.
+Abacus is a calculator built with extensibility and usability in mind. It provides a plugin interface, via Java, as Lua proves too difficult to link up to the Java core. The description of the internals of the project can be found on the wiki page.
 
 ## Current State
-Abacus is being built for the Northwest Advanced Programming Workshop, a 3 week program in which students work in treams to complete a single project, following principles of agile development. Because of its short timeframe, Abacus is not even close to completed state. Below is a list of the current features and problems.
+Abacus is being built for the Northwest Advanced Programming Workshop, a 3 week program in which students work in teams to complete a single project, following principles of agile development. Because of its short timeframe, Abacus is not even close to completed state. Below is a list of the current features and problems.
 - [x] Basic number class
 - [x] Implementation of basic functions 
 - [x] Implementation of `exp`, `ln`, `sqrt` using the basic functions and Taylor Series

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

@@ -1,5 +1,6 @@
 package org.nwapw.abacus.fx;
 
+import javafx.application.Platform;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 import javafx.fxml.FXML;
@@ -25,7 +26,10 @@ public class AbacusController {
      * Constant string that is displayed if the tree could not be reduced.
      */
     private static final String ERR_EVAL = "Evaluation Error";
-
+    /**
+     * Constant string that is displayed if the calculations are stopped before they are done.
+     */
+    private static final String ERR_STOP = "Stopped";
     @FXML
     private TableView<HistoryModel> historyTable;
     @FXML
@@ -54,6 +58,20 @@ public class AbacusController {
      */
     private ObservableList<String> numberImplementationOptions;
 
+    /**
+     * Thread used for calculating.
+     */
+    private Thread calcThread;
+
+    /**
+     * Checks whether the calculator is calculating.
+     */
+    private boolean calculating;
+
+    /**
+     * Seconds delayed for timer;
+     */
+    private double delay = 0;
     private Abacus abacus;
 
     @FXML
@@ -87,24 +105,63 @@ public class AbacusController {
 
     @FXML
     private void performCalculation(){
-        inputButton.setDisable(true);
+        Runnable calculator = new Runnable(){
-        TreeNode constructedTree = abacus.parseString(inputField.getText());
+            public void run() {
-        if(constructedTree == null){
+                if(delay>0) {
-            outputText.setText(ERR_SYNTAX);
+                    Runnable timer = new Runnable() {
-            inputButton.setDisable(false);
+                        public void run() {
-            return;
+                            long gap = (long) (delay * 1000);
-        }
+                            long startTime = System.currentTimeMillis();
-        NumberInterface evaluatedNumber = abacus.evaluateTree(constructedTree);
+                            while (System.currentTimeMillis() - startTime <= gap) {
-        if(evaluatedNumber == null){
+                            }
-            outputText.setText(ERR_EVAL);
+                            stopCalculation();
-            inputButton.setDisable(false);
+                        }
-            return;
+                    };
-        }
+                    Thread maxTime = new Thread(timer);
-        outputText.setText(evaluatedNumber.toString());
+                    maxTime.setName("maxTime");
-        historyData.add(new HistoryModel(inputField.getText(), constructedTree.toString(), evaluatedNumber.toString()));
+                    maxTime.start();
+                }
+                calculating = true;
+                Platform.runLater(() -> inputButton.setDisable(true));
+                TreeNode constructedTree = abacus.parseString(inputField.getText());
+                if (constructedTree == null) {
+                    Platform.runLater(() ->outputText.setText(ERR_SYNTAX));
+                    Platform.runLater(() -> inputButton.setDisable(false));
+                    //return;
+                }else {
+                    NumberInterface evaluatedNumber = abacus.evaluateTree(constructedTree);
+                    if (evaluatedNumber == null) {
+                        if(Thread.currentThread().isInterrupted()){
+                            Platform.runLater(() -> outputText.setText(ERR_STOP));
+                            Platform.runLater(() -> inputButton.setDisable(false));
+                        }else {
+                            Platform.runLater(() -> outputText.setText(ERR_EVAL));
+                            Platform.runLater(() -> inputButton.setDisable(false));
+                            //return;
+                        }
+                    } else {
+                        Platform.runLater(() -> outputText.setText(evaluatedNumber.toString()));
 
-        inputButton.setDisable(false);
+                        historyData.add(new HistoryModel(inputField.getText(), constructedTree.toString(), evaluatedNumber.toString()));
-        inputField.setText("");
+
+                        Platform.runLater(() -> inputButton.setDisable(false));
+                        Platform.runLater(() -> inputField.setText(""));
+                    }
+                }
+                calculating = false;
+            }
+        };
+        if(!calculating) {
+                calcThread = new Thread(calculator);
+                calcThread.setName("calcThread");
+                calcThread.start();
+        }
+    }
+    @FXML
+    private void stopCalculation(){
+        calcThread.interrupt();
+        calculating = false;
+        //Platform.runLater(() ->inputButton.setDisable(false));
     }
 
 }

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

@@ -31,9 +31,13 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             NumberInterface sum = params[0];
             for (int i = 1; i < params.length; i++) {
                 sum = sum.add(params[i]);
+                if(Thread.currentThread().isInterrupted())
+                    return null;
             }
             return sum;
         }
@@ -49,7 +53,10 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             return params[0].subtract(params[1]);
+
         }
     });
     /**
@@ -63,6 +70,8 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             return params[0].negate();
         }
     });
@@ -77,9 +86,13 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             NumberInterface product = params[0];
             for (int i = 1; i < params.length; i++) {
                 product = product.multiply(params[i]);
+                if(Thread.currentThread().isInterrupted())
+                    return null;
             }
             return product;
         }
@@ -95,6 +108,8 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             return params[0].divide(params[1]);
         }
     });
@@ -110,15 +125,19 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             if (params[0].signum() == 0) {
                 return (new NaiveNumber(1)).promoteTo(params[0].getClass());
             }
             NumberInterface factorial = params[0];
             NumberInterface multiplier = params[0];
             //It is necessary to later prevent calls of factorial on anything but non-negative integers.
-            while ((multiplier = multiplier.subtract(NaiveNumber.ONE.promoteTo(multiplier.getClass()))).signum() == 1) {
+            while (!Thread.currentThread().isInterrupted()&&(multiplier = multiplier.subtract(NaiveNumber.ONE.promoteTo(multiplier.getClass())))!=null&&multiplier.signum() == 1) {
                 factorial = factorial.multiply(multiplier);
             }
+            if(Thread.currentThread().isInterrupted())
+                return null;
             return factorial;
                 /*if(!storedList.containsKey(params[0].getClass())){
                     storedList.put(params[0].getClass(), new ArrayList<NumberInterface>());
@@ -138,7 +157,12 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
-            return FUNCTION_EXP.apply(FUNCTION_LN.apply(params[0]).multiply(params[1]));
+            if(Thread.currentThread().isInterrupted())
+                return null;
+            NumberInterface check;
+            if((check = FUNCTION_EXP.apply(FUNCTION_LN.apply(params[0])))!=null&&(check = check.multiply(params[1]))!=null)
+                return check;
+            return null;
         }
     });
     /**
@@ -152,6 +176,8 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             return params[0].multiply((new NaiveNumber(params[0].signum())).promoteTo(params[0].getClass()));
         }
     };
@@ -166,14 +192,17 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             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){
+                NumberInterface check;
+                while((check = FUNCTION_ABS.apply(currentTerm))!=null && (check.compareTo(maxError) > 0)){
                     n++;
-                    currentTerm = currentTerm.multiply(params[0]).divide((new NaiveNumber(n)).promoteTo(params[0].getClass()));
+                    if(Thread.currentThread().isInterrupted()||(currentTerm = currentTerm.multiply(params[0]))==null||(currentTerm = currentTerm.divide((new NaiveNumber(n)).promoteTo(params[0].getClass())))==null||(sum = (sum.add(currentTerm)))==null)
-                    sum = sum.add(currentTerm);
+                        return null;
                 }
                 return sum;
             }
@@ -182,18 +211,28 @@ public class StandardPlugin extends Plugin {
                 //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;
+                //NumberInterface left = params[0].multiply((new NaiveNumber(3)).promoteTo(params[0].getClass()).intPow(params[0].ceiling())), right = maxError;
+                NumberInterface check;
+                        if((check =intPow(new NaiveNumber(3).promoteTo(params[0].getClass()),params[0].getClass(),(new NaiveNumber(params[0].ceiling())).promoteTo(params[0].getClass())))==null)
+                            return null;
+                        NumberInterface left = params[0].multiply(check), right = maxError;
                 do{
-                    sum = sum.add(nextNumerator.divide(factorial(params[0].getClass(), n+1)));
+                    if((check = factorial(params[0].getClass(),n+1))==null||(check = nextNumerator.divide(check))==null||(sum = sum.add(check))==null)
+                        return null;
                     n++;
-                    nextNumerator = nextNumerator.multiply(params[0]);
+                    if((nextNumerator = nextNumerator.multiply(params[0]))==null)
-                    left = left.multiply(params[0]);
+                        return null;
+                    if((left = left.multiply(params[0]))==null)
+                        return null;
                     NumberInterface nextN = (new NaiveNumber(n+1)).promoteTo(params[0].getClass());
-                    right = right.multiply(nextN);
+                    if((right = right.multiply(nextN))==null)
+                        return null;
                     //System.out.println(left + ", " + right);
                 }
-                while(left.compareTo(right) > 0);
+                while(!Thread.currentThread().isInterrupted()&&left.compareTo(right) > 0);
                 //System.out.println(n+1);
+               if(Thread.currentThread().isInterrupted())
+                    return null;
                 return sum;
             }
         }
@@ -209,26 +248,32 @@ public class StandardPlugin extends Plugin {
 
         @Override
         protected NumberInterface applyInternal(NumberInterface[] params) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             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) {
+            NumberInterface check;
-                if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() == 1) {
+            while (!Thread.currentThread().isInterrupted()&&(check = FUNCTION_ABS.apply(param.subtract(NaiveNumber.ONE.promoteTo(param.getClass()))))!=null&&(check.compareTo((new NaiveNumber(0.1)).promoteTo(param.getClass()))) >= 0) {
+                if ((check = param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())))!=null&&check.signum() == 1) {
                     param = param.divide(new NaiveNumber(2).promoteTo(param.getClass()));
                     powersOf2++;
-                    if (param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())).signum() != 1) {
+                    if ((check = param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())))==null||check.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) {
+                    if ((check = param.subtract(NaiveNumber.ONE.promoteTo(param.getClass())))==null||check.signum() != 1) {
                         break;
                         //No infinite loop for you.
                     }
                 }
             }
-            return getLog2(param).multiply((new NaiveNumber(powersOf2)).promoteTo(param.getClass())).add(getLogPartialSum(param));
+            NumberInterface check2;
+            if(!Thread.currentThread().isInterrupted()&&(check = getLog2(param))!=null&&(check = check.multiply((new NaiveNumber(powersOf2).promoteTo(param.getClass()))))!=null&&(check2 = getLogPartialSum(param))!=null&&(check = check.add(check2))!=null)
+                   return check;
+            return null;
         }
 
         /**
@@ -238,16 +283,23 @@ public class StandardPlugin extends Plugin {
          * @return the partial sum.
          */
         private NumberInterface getLogPartialSum(NumberInterface x) {
+
+            if(Thread.currentThread().isInterrupted())
+                return null;
             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) {
+            NumberInterface check;
+            while (!Thread.currentThread().isInterrupted()&&(check = FUNCTION_ABS.apply(currentTerm))!=null&&check.compareTo(maxError) > 0) {
                 n++;
-                currentNumerator = currentNumerator.multiply(x).negate();
+                if((currentNumerator = currentNumerator.multiply(x))==null||(currentNumerator = currentNumerator.negate())==null)
+                    return null;
                 currentTerm = currentNumerator.divide(new NaiveNumber(n).promoteTo(x.getClass()));
                 sum = sum.add(currentTerm);
             }
+            if(Thread.currentThread().isInterrupted())
+                return null;
             return sum;
         }
 
@@ -257,6 +309,8 @@ public class StandardPlugin extends Plugin {
          * @return the value of log(2) with the appropriate precision.
          */
         private NumberInterface getLog2(NumberInterface number) {
+            if(Thread.currentThread().isInterrupted())
+                return null;
             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)
@@ -265,13 +319,17 @@ public class StandardPlugin extends Plugin {
             NumberInterface a = (new NaiveNumber(1)).promoteTo(number.getClass()), b = a, c = a;
             NumberInterface sum = NaiveNumber.ZERO.promoteTo(number.getClass());
             int n = 0;
-            while (a.compareTo(maxError) >= 1) {
+            while (!Thread.currentThread().isInterrupted()&&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));
+                NumberInterface check;
+                if(a==null||(check = a.add(b))==null||(check = check.multiply(c))==null||(sum = sum.add(check))==null)
+                    return null;
             }
+            if(Thread.currentThread().isInterrupted())
+                return null;
             return sum;
         }
     };
@@ -345,6 +403,8 @@ public class StandardPlugin extends Plugin {
     }
 
     public static NumberInterface factorial(Class<? extends NumberInterface> numberClass, int n){
+        if(Thread.currentThread().isInterrupted())
+            return null;
         if(!factorialLists.containsKey(numberClass)){
             factorialLists.put(numberClass, new ArrayList<>());
             factorialLists.get(numberClass).add(NaiveNumber.ONE.promoteTo(numberClass));
@@ -352,11 +412,34 @@ public class StandardPlugin extends Plugin {
         }
         ArrayList<NumberInterface> list = factorialLists.get(numberClass);
         if(n >= list.size()){
-            while(list.size() < n + 16){
+            while(!Thread.currentThread().isInterrupted()&&list.size() < n + 16){
                 list.add(list.get(list.size()-1).multiply(new NaiveNumber(list.size()).promoteTo(numberClass)));
             }
         }
+        if(Thread.currentThread().isInterrupted())
+            return null;
         return list.get(n);
     }
+    public static NumberInterface intPow(NumberInterface number, Class<? extends NumberInterface> numberClass,NumberInterface exponent) {
+        if(Thread.currentThread().isInterrupted())
+            return null;
+        if (exponent.compareTo((new NaiveNumber(0)).promoteTo(numberClass))==0) {
+            return (new NaiveNumber(1)).promoteTo(numberClass);
+        }
+        boolean takeReciprocal = exponent.compareTo((new NaiveNumber(0)).promoteTo(numberClass))<0;
+        exponent = FUNCTION_ABS.apply(exponent);
+        NumberInterface power = number;
+        for(NumberInterface currentExponent =(new NaiveNumber(1)).promoteTo(numberClass);currentExponent.compareTo(exponent)<0;currentExponent = currentExponent.add((new NaiveNumber(1)).promoteTo(numberClass))){
+            power = power.multiply(number);
+            if(Thread.currentThread().isInterrupted())
+                return null;
+        }
+        if (takeReciprocal) {
+            power = (new NaiveNumber(1)).promoteTo(numberClass).divide(power);
+        }
+        if(Thread.currentThread().isInterrupted())
+            return null;
+        return power;
+    }
 
 }

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

@@ -92,10 +92,15 @@ public class BinaryNode extends TreeNode {
 
     @Override
     public <T> T reduce(Reducer<T> reducer) {
+        if(Thread.currentThread().isInterrupted())
+            return null;
         T leftReduce = left.reduce(reducer);
         T rightReduce = right.reduce(reducer);
         if (leftReduce == null || rightReduce == null) return null;
-        return reducer.reduceNode(this, leftReduce, rightReduce);
+        T a = reducer.reduceNode(this, leftReduce, rightReduce);
+        if(Thread.currentThread().isInterrupted())
+            return null;
+        return a;
     }
 
     @Override

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

@@ -62,12 +62,17 @@ public class FunctionNode extends TreeNode {
 
     @Override
     public <T> T reduce(Reducer<T> reducer) {
+        if(Thread.currentThread().isInterrupted())
+            return null;
         Object[] reducedChildren = new Object[children.size()];
         for (int i = 0; i < reducedChildren.length; i++) {
             reducedChildren[i] = children.get(i).reduce(reducer);
-            if (reducedChildren[i] == null) return null;
+            if (Thread.currentThread().isInterrupted()||reducedChildren[i] == null) return null;
         }
-        return reducer.reduceNode(this, reducedChildren);
+        T a = reducer.reduceNode(this, reducedChildren);
+        if(Thread.currentThread().isInterrupted())
+            return null;
+        return a;
     }
 
     @Override

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

@@ -33,9 +33,14 @@ public class UnaryNode extends TreeNode {
 
     @Override
     public <T> T reduce(Reducer<T> reducer) {
+        if(Thread.currentThread().isInterrupted())
+            return null;
         Object reducedChild = applyTo.reduce(reducer);
         if (reducedChild == null) return null;
-        return reducer.reduceNode(this, reducedChild);
+        T a = reducer.reduceNode(this, reducedChild);
+        if(Thread.currentThread().isInterrupted())
+            return null;
+        return a;
     }
 
     /**

src/main/resources/abacus.fxml

@@ -37,6 +37,8 @@
                             <TextField fx:id="inputField" onAction="#performCalculation"/>
                             <Button fx:id="inputButton" text="Calculate" maxWidth="Infinity"
                                     onAction="#performCalculation"/>
+                            <Button fx:id="stopButton" text="Stop" maxWidth="Infinity"
+                                    onAction="#stopCalculation"/>
                         </VBox>
                     </bottom>
                 </BorderPane>