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

     CalcEngine() {
     }
 
-    public double add(double v, double v1) {
-        return Double.NaN;
-    }
+    public double add(double v, double v1) { 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;
     }
+
+    public double square(double v) {return v*v;}
+
+    public double squareroot(double v) { return Math.sqrt(v);}
+
+    public double exponent(double v, double v1) { return Math.pow(v, v1); }
+
+    public double inverse(double v) { return (1 / v); }
+
+    public double invert(double v) { return (-v); }
+
+    public double findSin(double v) { return Math.sin(v); }
+
+    public double findCos(double v) { return Math.cos(v); }
+
+    public double findTan(double v) { return Math.tan(v); }
 }

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

         launch(args);
     }
     private static final String[][] template = {
+            {"sin", "cos", "tan", "-x"},
+            { "x²", "√", "xⁿ", "1/x"},
             { "7", "8", "9", "/" },
             { "4", "5", "6", "*" },
             { "1", "2", "3", "-" },
     private DoubleProperty currentValue = new SimpleDoubleProperty();
     private CalcEngine calcEngine = new CalcEngine();
 
-    private enum Op { NOOP, ADD, SUBTRACT, MULTIPLY, DIVIDE }
+    private enum Op { NOOP, ADD, SUBTRACT, MULTIPLY, DIVIDE, SQUARE, SQUAREROOT, EXPONENT,
+    INVERSE, INVERT, FINDSIN, FINDCOS, FINDTAN}
 
     private Op curOp   = Op.NOOP;
     private Op stackOp = Op.NOOP;
             case "-": triggerOp.set(Op.SUBTRACT); break;
             case "*": triggerOp.set(Op.MULTIPLY); break;
             case "/": triggerOp.set(Op.DIVIDE);   break;
+            case "x²": triggerOp.set(Op.SQUARE);   break;
+            case "√": triggerOp.set(Op.SQUAREROOT); break;
+            case "xⁿ": triggerOp.set(Op.EXPONENT); break;
+            case "1/x": triggerOp.set(Op.INVERSE); break;
+            case "sin": triggerOp.set(Op.FINDSIN); break;
+            case "cos": triggerOp.set(Op.FINDCOS); break;
+            case "tan": triggerOp.set(Op.FINDTAN); break;
+            case "-x": triggerOp.set(Op.INVERT); break;
+
         }
         return triggerOp;
     }
         button.setOnAction(new EventHandler<ActionEvent>() {
             @Override
             public void handle(ActionEvent actionEvent) {
-                curOp = triggerOp.get();
+                if (triggerOp.get() == Op.SQUARE) {
+                    currentValue.set(calcEngine.square(currentValue.get()));
+                    stackOp = curOp;
+                    curOp = Op.NOOP;
+                }else if(triggerOp.get() ==  Op.SQUAREROOT){
+                    currentValue.set(calcEngine.squareroot(currentValue.get()));
+                    stackOp = curOp;
+                    curOp = Op.NOOP;
+                }else if(triggerOp.get() ==  Op.FINDCOS){
+                    currentValue.set(calcEngine.findCos(currentValue.get()));
+                    stackOp = curOp;
+                    curOp = Op.NOOP;
+                }else if(triggerOp.get() ==  Op.FINDSIN){
+                    currentValue.set(calcEngine.findSin(currentValue.get()));
+                    stackOp = curOp;
+                    curOp = Op.NOOP;
+                }else if(triggerOp.get() ==  Op.FINDTAN){
+                    currentValue.set(calcEngine.findTan(currentValue.get()));
+                    stackOp = curOp;
+                    curOp = Op.NOOP;
+                }else if(triggerOp.get() ==  Op.INVERSE){
+                    currentValue.set(calcEngine.inverse(currentValue.get()));
+                    stackOp = curOp;
+                    curOp = Op.NOOP;
+                }else if(triggerOp.get() ==  Op.INVERT){
+                    currentValue.set(calcEngine.invert(currentValue.get()));
+                    stackOp = curOp;
+                    curOp = Op.NOOP;
+                } else {
+                    curOp = triggerOp.get();
+                }
             }
         });
     }
                     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 SQUARE:   currentValue.set(calcEngine.square(currentValue.get())); break;
+                    case SQUAREROOT: currentValue.set(calcEngine.squareroot(previousValue.get())); break;
+                    case INVERSE: currentValue.set(calcEngine.inverse(currentValue.get())); break;
+                    case INVERT: currentValue.set(calcEngine.invert(currentValue.get())); break;
+                    case FINDSIN: currentValue.set(calcEngine.findSin(currentValue.get())); break;
+                    case FINDCOS: currentValue.set(calcEngine.findCos(currentValue.get())); break;
+                    case FINDTAN: currentValue.set(calcEngine.findTan(currentValue.get())); break;
+                    case EXPONENT: currentValue.set(calcEngine.exponent(previousValue.get(), currentValue.get())); break;
                 }
             }
         });