Submission for demo

README.md

@@ -1,6 +1,6 @@
 # ScientificCalculator (maven) ZCW
 
-
+## James
 ## Description
 
 In this project your team will build a small app to function as a calculator. This app  will be built in Java, and will use the topics and techniques discussed during the week.
@@ -63,7 +63,7 @@ Each operation should automatically update the display
   - Ln (natural logarithm)
   - e<sup>x</sup> (inverse natural logarithm)
 - Factorial function  
-
+//
 
 ### Custom Features
 

pom.xml

@@ -7,6 +7,18 @@
     <groupId>com.zipcodewilmington</groupId>
     <artifactId>scientific_calculator</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+<<<<<<< HEAD
+            <version>RELEASE</version>
+=======
+            <version>4.12</version>
+>>>>>>> fb9393f6415e572d2b4750a4662a151dc5895047
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 
 
 </project>

src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java

@@ -0,0 +1,35 @@
+package com.zipcodewilmington.scientificcalculator;
+
+public class BasicMath {
+    // two operator methods
+    public static Double addition (Double numberOne, Double numberTwo) {
+        return (numberOne + numberTwo);
+    }
+    public static Double subtraction (Double numberOne, Double numberTwo) {
+        return numberOne - numberTwo;
+    }
+    public static Double multiplication (Double numberOne, Double numberTwo) {
+            return numberOne * numberTwo;
+    }
+    public static Double division (Double numberOne, Double numberTwo) {
+        return numberOne / numberTwo;
+    }
+        public static Double exponent (Double numberOne, Double numberTwo){
+            return Math.pow(numberOne, numberTwo);
+    }
+    // one operator methods
+
+    public static Double square (Double numberOne) {
+        return numberOne * numberOne;
+    }
+    public static Double squareroot (Double numberOne){
+        return (Math.sqrt(numberOne));
+    }
+    public static Double inverse(Double numberOne){
+        return 1/numberOne;
+    }
+}
+
+
+
+

src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java

@@ -0,0 +1,59 @@
+package com.zipcodewilmington.scientificcalculator;
+
+import java.util.ArrayList;
+
+public class BoxMaker {
+    private int width;
+
+    public BoxMaker() {
+        width = 30;
+    }
+
+    public BoxMaker(int initialWidth)
+    {
+        width = initialWidth;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public void setWidth(int newWidth)
+    {
+        if(newWidth > 3 && newWidth < 151)
+        {
+            width = newWidth;
+        }
+    }
+
+    public String draw(String ... input) {
+        StringBuilder output = new StringBuilder();
+
+        output.append("╔");
+        for (int i = 0; i < width - 2; i++) {
+            output.append("═");
+        }
+        output.append("╗\n");
+
+        for (String element : input) {
+            String line = "";
+            StringBuilder lineFormat = new StringBuilder();
+            lineFormat.append("%");
+            lineFormat.append(width - 2);
+            lineFormat.append("s");
+
+            line = String.format(lineFormat.toString(), element);
+            output.append("║");
+            output.append(line);
+            output.append("║\n");
+        }
+
+        output.append("╚");
+        for (int i = 0; i < width - 2; i++) {
+            output.append("═");
+        }
+        output.append("╝\n");
+
+        return output.toString();
+    }
+}

src/main/java/com/zipcodewilmington/scientificcalculator/Console.java

@@ -23,10 +23,18 @@ public static String getStringInput(String prompt) {
     }
 
     public static Integer getIntegerInput(String prompt) {
-        return null;
+        Scanner scanner = new Scanner(System.in);
+        println(prompt);
+        String userInput;
+        userInput = scanner.nextLine();
+        return Integer.parseInt(userInput);
     }
 
     public static Double getDoubleInput(String prompt) {
-        return null;
+        Scanner scanner = new Scanner(System.in);
+        println(prompt);
+        String userInput;
+        userInput = scanner.nextLine();
+        return Double.parseDouble(userInput);
     }
-}
+}

src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java

@@ -0,0 +1,27 @@
+package com.zipcodewilmington.scientificcalculator;
+
+public class ConversionMath {
+
+    public static Double feetToMeters (Double numberOne) {
+        return numberOne / 3.2810;
+    }
+    public static Double metersToFeet (Double numberOne) {
+        return  numberOne *  3.28084;
+    }
+    public static Double poundsToKilos(Double numberOne) {
+        return  numberOne / 2.205;
+    }
+    public static Double kilosToPounds(Double numberOne) {
+        return numberOne * 2.205;
+    }
+    public static Double fahrenheitToCelsius (Double numberOne) {
+        return ((numberOne - 32) * 5 / 9);
+    }
+    public static Double celsiusToFahrenheit (Double numberOne) {
+            return ((numberOne * 9 / 5) + 32);
+        }
+
+
+}
+
+

src/main/java/com/zipcodewilmington/scientificcalculator/Display.java

@@ -0,0 +1,164 @@
+package com.zipcodewilmington.scientificcalculator;
+
+import javax.swing.*;
+import java.io.DataInput;
+
+public class Display {
+    private int displayWidth;
+    private BoxMaker displayBox;
+    private Double currentValue;
+//    private String currentOperation;  Moving to input
+    public enum Modes { BINARY, OCTAL, DEC, HEX }
+    private Modes mode;
+    private Boolean isRadians;
+    Boolean error;
+
+    public Display()
+    {
+        currentValue = 0.0;
+        mode = Modes.DEC;
+        displayWidth = 50;
+        displayBox = new BoxMaker(displayWidth);
+        isRadians = false;
+        error = false;
+    }
+
+    public void setDisplay(Double inputValue)
+    {
+        if (inputValue.isNaN() || inputValue.isInfinite())
+        {
+            error = true;
+        }
+        else {
+            currentValue = inputValue;
+        }
+    }
+
+    public Double getDisplay()
+    {
+        return currentValue;
+    }
+
+    // Future implimentation, running out of time to format correctly with DEG/RAD and
+    // BINARY/OCTAL/HEX left-justification on display
+    public void setDisplayWidth(int newWidth)
+    {
+        displayWidth = newWidth;
+    }
+
+    public String update() {
+        String output = "";
+        String radianLine = "";
+        String valueLine = "";
+        String baseLine = "";
+
+        if (error) {
+            radianLine = String.format("%-46s", "ERR");
+            valueLine = "ERR ";
+            baseLine = String.format("%-46s", "ERR");
+            output = displayBox.draw(radianLine, valueLine, baseLine);
+        } else {
+            if (isRadians == true) {
+                radianLine = String.format("%-46s", "RAD");
+            } else {
+                radianLine = " ";
+            }
+
+
+            // This needs to be fixed
+            if (mode == Modes.BINARY) {
+                baseLine = String.format("%-46s", "BIN");
+                valueLine = Integer.toBinaryString(currentValue.intValue()) + " ";
+            } else if (mode == Modes.OCTAL) {
+                baseLine = String.format("%-46s", "OCTAL");
+                valueLine = Integer.toOctalString(currentValue.intValue()) + " ";
+            } else if (mode == Modes.DEC) {
+                if (currentValue % 1 == 0) // No decimal
+                {
+                    valueLine = Integer.toString(currentValue.intValue()) + " ";
+                } else {
+                    valueLine = Double.toString(currentValue) + " ";
+                }
+            } else if (mode == Modes.HEX) {
+                baseLine = String.format("%-46s", "HEX");
+                valueLine = Integer.toHexString(currentValue.intValue()) + " ";
+            }
+        }
+
+        output = displayBox.draw(radianLine, valueLine, baseLine);
+        Console.println("%s", output);
+        return output;
+    }
+
+    public void setMode(Modes newMode)
+    {
+        mode = newMode;
+    }
+
+    public void setMode() {
+        switch (mode)
+        {
+            case DEC:
+                setMode(Modes.BINARY);
+                break;
+            case BINARY:
+                setMode(Modes.OCTAL);
+                break;
+            case OCTAL:
+                setMode(Modes.HEX);
+                break;
+            case HEX:
+                setMode(Modes.DEC);
+                break;
+        }
+
+        // Considering updating currentVal here, but makes math more difficult
+        // since Math assumes decimal math.
+    }
+
+    public Modes getMode()
+    {
+        return mode;
+    }
+
+    public void clear() {
+        currentValue = 0.0;
+        error = false;
+        isRadians = false;
+        mode = Modes.DEC;
+        // Send a command to input to remove last operation and last value input
+    }
+
+    public void invSign()
+    {
+        currentValue *= -1.0;
+    }
+
+    public Double absoluteValue()
+    {
+        if(currentValue < 0)
+        {
+            return currentValue * -1;
+        }
+        else
+        {
+            return currentValue;
+        }
+    }
+
+    public void toggleRadians()
+    {
+        isRadians = !isRadians;
+    }
+
+    public Boolean getIsRadians()
+    {
+        return isRadians;
+    }
+
+    public Boolean getErr() {
+        return error;
+    }
+
+    // Make a toggle to switch from normal notation to scientific notation
+}