Completed Calc

pom.xml

@@ -7,6 +7,32 @@
     <groupId>com.zipcodewilmington</groupId>
     <artifactId>scientific_calculator</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>7</source>
+                    <target>7</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 
 
 </project>

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

@@ -0,0 +1,99 @@
+package com.zipcodewilmington.scientificcalculator;
+
+public class BasicCalculator {
+
+    //fields for storing results
+    private Double doubleResult;
+    private String stringResult;
+
+    //initializing an error class
+    Error error = new Error();
+
+    //Constructor
+    public BasicCalculator(){
+        doubleResult = null;
+        stringResult = "0";
+    }
+
+    //Basic Operator functions
+    public void add(Double x, Double y){
+        try {
+
+            this.setDoubleResult(x + y);
+            this.setStringResult(Double.toString(x + y));
+        }
+
+        //for non-double inputs
+        catch(Exception e){
+            this.setDoubleResult(null);
+            this.setStringResult("ERROR");
+        }
+    }
+
+    public void subtract(Double x, Double y){
+        try {
+            this.setDoubleResult(x - y);
+            this.setStringResult(Double.toString(x - y));
+
+        }
+        //for non double inputs
+        catch(Exception e){
+            this.setDoubleResult(null);
+            this.setStringResult("ERROR");
+        }
+    }
+
+    public void multiply(Double x, Double y){
+        try {
+            this.setDoubleResult(x * y);
+            this.setStringResult(Double.toString(x * y));
+
+        }
+        //for non double inputs
+        catch(Exception e){
+            this.setDoubleResult(null);
+            this.setStringResult("ERROR");
+        }
+    }
+
+    public void divide(Double x, Double y){
+        try {
+            if (error.IsBadValue(x, 0.0)){
+                this.setDoubleResult(null);
+                this.setStringResult("ERROR");
+            }
+            else {
+                this.setDoubleResult(x / y);
+                this.setStringResult(Double.toString(x / y));
+            }
+        }
+        //for non double inputs.
+        catch(Exception e){
+            this.setDoubleResult(null);
+            this.setStringResult("ERROR");
+        }
+    }
+
+
+    //Getters and Setters for class fields
+
+    public double getDoubleResult() {
+        return doubleResult;
+    }
+
+    public void setDoubleResult(Double doubleResult) {
+        double number = (Math.round(doubleResult * 1000.0))/1000.0;
+        this.doubleResult = number;
+    }
+
+    public String getStringResult() {
+        return stringResult;
+    }
+
+    public void setStringResult(String stringResult) {
+        this.stringResult = stringResult;
+    }
+
+
+
+}

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

@@ -7,6 +7,10 @@
  */
 public class Console {
 
+    public void updatedisplay(){
+
+    }
+
     public static void print(String output, Object... args) {
         System.out.printf(output, args);
     }
@@ -17,16 +21,22 @@ public static void println(String output, Object... args) {
 
     public static String getStringInput(String prompt) {
         Scanner scanner = new Scanner(System.in);
-        println(prompt);
+        print(prompt);
         String userInput = scanner.nextLine();
         return userInput;
     }
 
     public static Integer getIntegerInput(String prompt) {
-        return null;
+        Scanner scanner = new Scanner(System.in);
+        print(prompt);
+        Integer userInput = Integer.valueOf(scanner.nextLine());
+        return userInput;
     }
 
     public static Double getDoubleInput(String prompt) {
-        return null;
+        Scanner scanner = new Scanner(System.in);
+        print(prompt);
+        Double userInput = Double.valueOf(scanner.nextLine());
+        return userInput;
     }
 }

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

@@ -0,0 +1,140 @@
+package com.zipcodewilmington.scientificcalculator;
+
+//import com.sun.jdi.connect.Connector;
+
+public class ConversionCalculator {
+
+    //fields for storing results
+    private Double doubleResult;
+    private String stringResult;
+
+    //Constructor
+    public ConversionCalculator(){
+        doubleResult = 0.0;
+        stringResult = "0";
+    }
+
+    //Scientific Operator Conversion functions
+    //(binary, octal, decimal, hexadecimal)
+    public void binary(int x){
+        try {
+            this.setStringResult(Integer.toBinaryString(x));
+        }
+
+        //for non-double inputs
+        catch(Exception e){
+            this.setDoubleResult((double) 0);
+            this.setStringResult("ERROR");
+        }
+    }
+
+    public void binaryToInt(String x){
+        try {
+            Integer y = Integer.parseInt(x,2);
+
+            this.setStringResult(y.toString());
+        }
+
+        //for non-double inputs
+        catch(Exception e){
+            this.setDoubleResult((double) 0);
+            this.setStringResult("ERROR");
+        }
+    }
+
+    public void octal(int x){
+        try {
+
+            //this.setDoubleResult(Math.pow(x));
+            this.setStringResult(Integer.toOctalString(x));
+        }
+
+        //for non-double inputs
+        catch(Exception e){
+            this.setDoubleResult((double) 0);
+            this.setStringResult("ERROR");
+        }
+    }
+
+    public void octalToInt(String x){
+        try {
+            Integer y = Integer.parseInt(x,8);
+
+            this.setStringResult(y.toString());
+        }
+
+        //for non-double inputs
+        catch(Exception e){
+            this.setDoubleResult((double) 0);
+            this.setStringResult("ERROR");
+        }
+    }
+
+    public void decimal(int x){
+        try {
+
+            double y = x;
+            this.setDoubleResult(y);
+            this.setStringResult(Double.toString(y));
+        }
+
+        //for non-double inputs
+        catch(Exception e){
+            this.setDoubleResult((double) 0);
+            this.setStringResult("ERROR");
+        }
+    }
+
+    public void hexadecimal(int x){
+        try {
+
+            this.setStringResult(Integer.toHexString(x));
+        }
+
+        //for non-double inputs
+        catch(Exception e){
+            this.setDoubleResult((double) 0);
+            this.setStringResult("ERROR");
+        }
+    }
+
+    public void hexadecimalToInt(String x){
+        try {
+            Integer y = Integer.parseInt(x,16);
+
+            this.setStringResult(y.toString());
+        }
+
+        //for non-double inputs
+        catch(Exception e){
+            this.setDoubleResult((double) 0);
+            this.setStringResult("ERROR");
+        }
+    }
+
+
+
+
+
+    //Getters and Setters for class fields
+
+    public double getDoubleResult() {
+        return doubleResult;
+    }
+
+    public void setDoubleResult(Double doubleResult) {
+        double number = (Math.round(doubleResult * 1000.0))/1000.0;
+        this.doubleResult = number;
+    }
+
+    public String getStringResult() {
+        return stringResult;
+    }
+
+    public void setStringResult(String stringResult) {
+        this.stringResult = stringResult;
+    }
+
+
+
+}

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

@@ -0,0 +1,50 @@
+package com.zipcodewilmington.scientificcalculator;
+
+public class Error {
+
+    //these methods checks an input value against a series of possible
+    //values which could cause an error.
+
+    public boolean IssBadValue(Double input, Double[] not_this){
+
+        for (int i = 0 ;i < not_this.length;i++) {
+
+            if (input == not_this[i]) {
+                return true;
+            }
+        }
+    return false;
+    }
+
+    public boolean IsBadValue(Double input, Double not_this){
+
+        if (input == not_this) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    public boolean checkForBadTrigValues(Double input, Double not_this){ //not_this MUST be a positive value
+        while(input < -not_this){
+            input += (2 * not_this);
+        }
+        while(input > not_this){
+            input -= (2 * not_this);
+        }
+        if(input == not_this || input == -not_this){
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+
+    public boolean checkForOutsideRange(Double input, Double lowerlimit, Double higherlimit){
+        if(input < lowerlimit || input > higherlimit){
+            return true;
+        }
+        return false;
+    }
+}