It kinda works, but not really. Its actually terrible. I need to do alot more work on it.

src/main/java/rocks/zipcode/calcskin/CalcEngine.java

     }
 
     public double add(double v, double v1) {
-        return Double.NaN;
+
+        return v + v1;
     }
 
     public double subtract(double v, double v1) {
-        return Double.NaN;
+
+        return v - v1;
     }
 
     public double multiply(double v, double v1) {
-        return Double.NaN;
+
+        return v * v1;
     }
 
     public double divide(double v, double v1) {
-        return Double.NaN;
+
+        return v / v1;
     }
 }

src/main/java/rocks/zipcode/calcskin/CalcSkin.java

 
     private DoubleProperty previousValue = new SimpleDoubleProperty();
     private DoubleProperty currentValue = new SimpleDoubleProperty();
-    private CalcEngine calcEngine = new CalcEngine();
+    private ScientificCalculator scientificCalculator = new ScientificCalculator();
 
     private enum Op { NOOP, ADD, SUBTRACT, MULTIPLY, DIVIDE }
 
             @Override
             public void handle(ActionEvent actionEvent) {
                 if (curOp == Op.NOOP) {
-                    currentValue.set(currentValue.get() * 10 + Integer.parseInt(s));
+                    currentValue.set(currentValue.get() * 10 + Double.parseDouble(s));
                 } else {
                     previousValue.set(currentValue.get());
-                    currentValue.set(Integer.parseInt(s));
+                    currentValue.set(Double.parseDouble(s));
                     stackOp = curOp;
                     curOp = Op.NOOP;
                 }
             @Override
             public void handle(ActionEvent actionEvent) {
                 switch (stackOp) {
-                    case ADD:      currentValue.set(calcEngine.add(previousValue.get(), currentValue.get())); break;
-                    case SUBTRACT: currentValue.set(calcEngine.subtract(previousValue.get(), currentValue.get())); break;
-                    case MULTIPLY: currentValue.set(calcEngine.multiply(previousValue.get(), currentValue.get())); break;
-                    case DIVIDE:   currentValue.set(calcEngine.divide(previousValue.get(), currentValue.get())); break;
+                    case ADD:      currentValue.set(scientificCalculator.add(previousValue.get(), currentValue.get())); break;
+                    case SUBTRACT: currentValue.set(scientificCalculator.subtract(previousValue.get(), currentValue.get())); break;
+                    case MULTIPLY: currentValue.set(scientificCalculator.multiply(previousValue.get(), currentValue.get())); break;
+                    case DIVIDE:   currentValue.set(scientificCalculator.divide(previousValue.get(), currentValue.get())); break;
                 }
             }
         });

src/main/java/rocks/zipcode/calcskin/Calculator.java

+package rocks.zipcode.calcskin;
+
+public class Calculator {
+
+        public double add(double v, double v1)
+        {
+            return v + v1;
+        }
+
+        public double multiply(double v, double v1)
+        {
+            return v * v1;
+        }
+
+        public double subtract(double v, double v1)
+        {
+            return v - v1;
+        }
+
+        public double divide(double v, double v1)
+        {
+            return v / v1;
+        }
+
+
+}

src/main/java/rocks/zipcode/calcskin/ScientificCalculator.java

+package rocks.zipcode.calcskin;
+
+public class ScientificCalculator extends Calculator{
+
+    public double power(double v, double v1)
+    {
+        double c = (double)Math.pow(v, v1);
+        return c;
+    }
+
+    public double factorial (double v)
+    {
+        if(v <= 1)
+        {
+            return 1;
+        }
+        else
+            return v * factorial(v-1);
+    }
+}