complete

pom.xml

                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
-                    <source>1.7</source>
-                    <target>1.7</target>
+                    <source>8</source>
+                    <target>8</target>
                 </configuration>
             </plugin>
         </plugins>

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

 package rocks.zipcode.calcskin;
 
 public class CalcEngine {
-
+//ended up using my original calc class. See Calculator
     CalcEngine() {
     }
 

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

 import javafx.application.Application;
 import javafx.beans.binding.Bindings;
 import javafx.beans.property.*;
-import javafx.event.ActionEvent;
-import javafx.event.EventHandler;
 import javafx.geometry.Pos;
 import javafx.scene.Scene;
 import javafx.scene.control.*;
 import javafx.scene.layout.*;
 import javafx.stage.Stage;
 import javafx.stage.StageStyle;
-import rocks.zipcode.calcskin.CalcEngine;
 
 import java.util.HashMap;
 import java.util.Map;
 // a simple JavaFX calculator.
 public class CalcSkin extends Application {
 
+
     public static void main(String[] args){
         launch(args);
     }
+
     private static final String[][] template = {
-            { "7", "8", "9", "/" },
-            { "4", "5", "6", "*" },
-            { "1", "2", "3", "-" },
-            { "0", "c", "=", "+" }
+            {"tan","cos","sin", "\u221A"},
+            { "M+", "MC", "MRC","!"},
+            {"+/-", "x\u00B2","x^y", "1/x"},
+            {"7", "8", "9", "/"},
+            {"4", "5", "6", "*"},
+            {"1","2", "3", "-"},
+            { "0", "c", "=", "+"}
     };
 
     private final Map<String, Button> accelerators = new HashMap<>();
 
     private DoubleProperty previousValue = new SimpleDoubleProperty();
     private DoubleProperty currentValue = new SimpleDoubleProperty();
-    private CalcEngine calcEngine = new CalcEngine();
+    private Calculator calc = new Calculator();
 
-    private enum Op { NOOP, ADD, SUBTRACT, MULTIPLY, DIVIDE }
+    private enum Op { NOOP, ADD, SUBTRACT, MULTIPLY, DIVIDE,
+                    SIGN, SQUARE, EXPONENT, INVERT, MEMORY, MEMCLEAR,
+                    MEMRECALL, FACTORIAL, TANGENT, COSINE, SINE, SQRT }
 
     private Op curOp   = Op.NOOP;
     private Op stackOp = Op.NOOP;
     }
 
     private void handleAccelerators(VBox layout) {
-        layout.addEventFilter(KeyEvent.KEY_PRESSED, new EventHandler<KeyEvent>() {
-            @Override
-            public void handle(KeyEvent keyEvent) {
-                Button activated = accelerators.get(keyEvent.getText());
-                if (activated != null) {
-                    activated.fire();
-                }
+        layout.addEventFilter(KeyEvent.KEY_PRESSED, keyEvent -> {
+            Button activated = accelerators.get(keyEvent.getText());
+            if (activated != null) {
+                activated.fire();
             }
         });
     }
         screen.setStyle("-fx-background-color: aquamarine;");
         screen.setAlignment(Pos.CENTER_RIGHT);
         screen.setEditable(false);
-        screen.textProperty().bind(Bindings.format("%.0f", currentValue));
+        screen.textProperty().bind(Bindings.format("%.2f", currentValue));
         return screen;
     }
 
             case "-": triggerOp.set(Op.SUBTRACT); break;
             case "*": triggerOp.set(Op.MULTIPLY); break;
             case "/": triggerOp.set(Op.DIVIDE);   break;
+            case "+/-": triggerOp.set(Op.SIGN); break;
+            case "x\u00B2": triggerOp.set(Op.SQUARE); break;
+            case "x^y": triggerOp.set(Op.EXPONENT); break;
+            case "1/x": triggerOp.set(Op.INVERT); break;
+            case "M+": triggerOp.set(Op.MEMORY); break;
+            case "MC": triggerOp.set(Op.MEMCLEAR); break;
+            case "MRC": triggerOp.set(Op.MEMRECALL); break;
+            case "!": triggerOp.set(Op.FACTORIAL); break;
+            case "tan": triggerOp.set(Op.TANGENT); break;
+            case "cos": triggerOp.set(Op.COSINE); break;
+            case "sin": triggerOp.set(Op.SINE); break;
+            case "\u221A": triggerOp.set(Op.SQRT); break;
         }
         return triggerOp;
     }
 
     private void makeOperandButton(Button button, final ObjectProperty<Op> triggerOp) {
         button.setStyle("-fx-base: lightgray;");
-        button.setOnAction(new EventHandler<ActionEvent>() {
-            @Override
-            public void handle(ActionEvent actionEvent) {
-                curOp = triggerOp.get();
-            }
+        button.setOnAction(actionEvent -> {
+            curOp = triggerOp.get();
+                switch (curOp) {
+                    case SIGN: currentValue.set(calc.changeSign(currentValue.get())); break;
+                    case SQUARE: currentValue.set(calc.square(currentValue.get())); break;
+                    case SQRT: currentValue.set(calc.squareRoot(currentValue.get())); break;
+                    case MEMORY: calc.storeMemory(currentValue.get());      break;
+                    case MEMCLEAR: calc.clearMemory();     break;
+                    case MEMRECALL: currentValue.set(calc.getMemory());    break;
+                    case FACTORIAL: currentValue.set(calc.factorial(currentValue.get()));  break;
+                    case INVERT: currentValue.set(calc.invert(currentValue.get()));  break;
+                    case TANGENT:  currentValue.set(TrigFunctions.tangent(currentValue.get()));  break;
+                    case COSINE:  currentValue.set(TrigFunctions.cosine(currentValue.get()));   break;
+                    case SINE:  currentValue.set(TrigFunctions.sin(currentValue.get())); break;
+                }
         });
     }
 
+
     private Button makeStandardButton(String s) {
         Button button = new Button(s);
         button.setStyle("-fx-base: beige;");
     }
 
     private void makeNumericButton(final String s, Button button) {
-        button.setOnAction(new EventHandler<ActionEvent>() {
-            @Override
-            public void handle(ActionEvent actionEvent) {
-                if (curOp == Op.NOOP) {
-                    currentValue.set(currentValue.get() * 10 + Integer.parseInt(s));
-                } else {
-                    previousValue.set(currentValue.get());
-                    currentValue.set(Integer.parseInt(s));
-                    stackOp = curOp;
-                    curOp = Op.NOOP;
-                }
+        button.setOnAction(actionEvent -> {
+            if (curOp == Op.NOOP) {
+                currentValue.set(currentValue.get() * 10 + Double.parseDouble(s));
+            } else {
+                previousValue.set(currentValue.get());
+                currentValue.set(Integer.parseInt(s));
+                stackOp = curOp;
+                curOp = Op.NOOP;
             }
         });
     }
 
     private void makeClearButton(Button button) {
         button.setStyle("-fx-base: mistyrose;");
-        button.setOnAction(new EventHandler<ActionEvent>() {
-            @Override
-            public void handle(ActionEvent actionEvent) {
-                currentValue.set(0);
-            }
-        });
+        button.setOnAction(actionEvent -> currentValue.set(0));
     }
 
     private void makeEqualsButton(Button button) {
         button.setStyle("-fx-base: ghostwhite;");
-        button.setOnAction(new EventHandler<ActionEvent>() {
-            @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;
-                }
+        button.setOnAction(actionEvent -> {
+            switch (stackOp) {
+                case ADD:      currentValue.set(calc.add(previousValue.get(), currentValue.get())); break;
+                case SUBTRACT: currentValue.set(calc.subtract(previousValue.get(), currentValue.get())); break;
+                case MULTIPLY: currentValue.set(calc.multiply(previousValue.get(), currentValue.get())); break;
+                case DIVIDE:   currentValue.set(calc.divide(previousValue.get(), currentValue.get())); break;
+                case EXPONENT:   currentValue.set(calc.exponent(previousValue.get(), currentValue.get())); break;
             }
         });
     }