diff --git a/UML diagram.png b/UML diagram.png new file mode 100644 index 00000000..66fee7a3 Binary files /dev/null and b/UML diagram.png differ diff --git a/pom.xml b/pom.xml index e7cb4f6b..d8cd763e 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,14 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + + junit + junit + 4.12 + test + + \ No newline at end of file diff --git a/scientificcalculator.uml b/scientificcalculator.uml new file mode 100644 index 00000000..b9879a5c --- /dev/null +++ b/scientificcalculator.uml @@ -0,0 +1,26 @@ + + + JAVA + com.zipcodewilmington.scientificcalculator + + com.zipcodewilmington.scientificcalculator.Calculator + com.zipcodewilmington.scientificcalculator.MathMethods + com.zipcodewilmington.scientificcalculator.MainApplication + com.zipcodewilmington.scientificcalculator.AskNumber + com.zipcodewilmington.scientificcalculator.Console + + + + + + com.zipcodewilmington.scientificcalculator.Calculator + + + Fields + Methods + Constructors + + All + private + + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/AskNumber.java b/src/main/java/com/zipcodewilmington/scientificcalculator/AskNumber.java new file mode 100644 index 00000000..f75839d4 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/AskNumber.java @@ -0,0 +1,25 @@ +package com.zipcodewilmington.scientificcalculator; + +public class AskNumber { + + // Ask for a Double + + public static double askDouble() { + double d = 0; + d = Console.getDoubleInput("Enter a number."); + return d; + } + + // Ask for an Operator + + public static String getOperation() { + String operator = ""; + String menu = "\nPlease type one of the following \nAdd Subtract Multiply Divide Remainder Square SquareRoot VariableExpo\nInverse -Num M+ MC MRC Sine Cosine Tangent Clear"; + operator = Console.getStringInput("What would you like to do?" + menu); + while(!operator.equalsIgnoreCase("Add") && !operator.equalsIgnoreCase("Subtract") && !operator.equalsIgnoreCase("Multiply") && !operator.equalsIgnoreCase("Divide") && !operator.equalsIgnoreCase("Remainder") && !operator.equalsIgnoreCase("Square") && !operator.equalsIgnoreCase("SquareRoot") && !operator.equalsIgnoreCase("VariableExpo") && !operator.equalsIgnoreCase("Inverse") && !operator.equalsIgnoreCase("-Num") && !operator.equalsIgnoreCase("M+") && !operator.equalsIgnoreCase("MC") && !operator.equalsIgnoreCase("MRC") && !operator.equalsIgnoreCase("Sine") && !operator.equalsIgnoreCase("Cosine") && !operator.equalsIgnoreCase("Tangent") && !operator.equalsIgnoreCase("Clear")){ + Console.println("You selected " + operator); + operator = Console.getStringInput("Invalid Input! Please type one of the following" + menu); + } + return operator; + } +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java new file mode 100644 index 00000000..b8ffea49 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -0,0 +1,46 @@ +package com.zipcodewilmington.scientificcalculator; + +import java.util.Scanner; + +public class Calculator { + double firstVal ; + double secondVal ; + double savedVal ; + double displayVal ; + + public Calculator(double firstValIn, double secondValIn, double displayValIn, double savedValIn) { + this.firstVal = firstValIn; + this.secondVal = secondValIn; + this.displayVal = displayValIn; + this.savedVal = savedValIn; + } + + public void setFirstVal(String prompt) { + Scanner doubleScanner = new Scanner(System.in); + Console.println(prompt); + while (!doubleScanner.hasNextDouble()) { + doubleScanner.next(); + Console.println("Invalid Input! Please enter a Double."); + } + this.displayVal = doubleScanner.nextDouble(); + this.firstVal = this.displayVal; + } + + public double getDisplayVal() { + return displayVal; + } + + public void clearDisplayVal() { + this.displayVal = 0; + Console.println("Your current total is %.2f", displayVal); + } + + public void setSavedVal(double a) { + this.savedVal = a; + } + + public double getSavedVal() { + return savedVal; + } + +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 83f0e97f..9197dec4 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -16,17 +16,33 @@ public static void println(String output, Object... args) { } public static String getStringInput(String prompt) { - Scanner scanner = new Scanner(System.in); + Scanner strScanner = new Scanner(System.in); println(prompt); - String userInput = scanner.nextLine(); - return userInput; + String strInput = strScanner.nextLine(); + return strInput; } - public static Integer getIntegerInput(String prompt) { - return null; + public static String evalMenuOption(String m){ + if (m.equals("A")) { + println("your string is " + m); + } else if (m.equals("B")) { + println("your string is " + m); + } else { + println("Invalid Input! Please type A for Integer or B for Double"); + println("your string is " + m); + } + return m; } - public static Double getDoubleInput(String prompt) { - return null; + public static double getDoubleInput(String prompt) { + Scanner doubleScanner = new Scanner(System.in); + println(prompt); + while (!doubleScanner.hasNextDouble()) { + doubleScanner.next(); + println("Invalid Input! Please enter a Double."); + } + double doubleInput = doubleScanner.nextDouble(); + + return doubleInput; } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f421325..42ddac91 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -4,14 +4,97 @@ * Created by leon on 2/9/18. */ public class MainApplication { + public static void main(String[] args) { - Console.println("Welcome to my calculator!"); - String s = Console.getStringInput("Enter a string"); - Integer i = Console.getIntegerInput("Enter an integer"); - Double d = Console.getDoubleInput("Enter a double."); - - Console.println("The user input %s as a string", s); - Console.println("The user input %s as a integer", i); - Console.println("The user input %s as a d", d); + + + //New User + Calculator user = new Calculator(0, 0, 0, 0); + Console.println("Simple Calculator!"); + + /////Print Starting Display + Console.println("Your current total is %.2f", user.getDisplayVal()); + + //Start Program 1st Round + while (true) { + + //Stores Operation + String operator = ""; + + //Get first value and set to display value + user.setFirstVal("Enter a starting value"); + Console.println("Your current total is %.2f", user.getDisplayVal()); + + //Start program operations loop + while (true) { + //Ask for operation and print to console + String nextOperator; + nextOperator = AskNumber.getOperation(); + + if (nextOperator.equalsIgnoreCase("Add")) { + user.secondVal = AskNumber.askDouble(); + user.displayVal = MathMethods.add(user.displayVal, user.secondVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("Subtract")) { + user.secondVal = AskNumber.askDouble(); + user.displayVal = MathMethods.subtract(user.displayVal, user.secondVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("Multiply")) { + user.secondVal = AskNumber.askDouble(); + user.displayVal = MathMethods.multiplication(user.displayVal, user.secondVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("Divide")) { + user.secondVal = AskNumber.askDouble(); + if (user.secondVal == 0) { + Console.println("ERROR!"); + user.displayVal = 0; + Console.println("Your current total is %.2f", user.getDisplayVal()); + user.setFirstVal("Enter a starting value"); + } else + user.displayVal = MathMethods.division(user.displayVal, user.secondVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("Remainder")) { + user.secondVal = AskNumber.askDouble(); + user.displayVal = MathMethods.remainder(user.displayVal, user.secondVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("Square")) { + user.displayVal = MathMethods.square(user.displayVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("SquareRoot")) { + user.displayVal = MathMethods.squareRoot(user.displayVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("VariableExpo")) { + user.secondVal = AskNumber.askDouble(); + user.displayVal = MathMethods.variExpo(user.displayVal,user.secondVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("Inverse")) { + user.displayVal = MathMethods.inverse(user.displayVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("-Num")) { + user.displayVal = MathMethods.invert(user.displayVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("M+")) { + user.savedVal = user.displayVal; + Console.println("You saved " + user.savedVal + " in memory."); + } else if (nextOperator.equalsIgnoreCase("MC")) { + user.savedVal = 0; + Console.println("Memory reset."); + } else if (nextOperator.equalsIgnoreCase("MRC")) { + Console.println("Your saved number is " + user.savedVal); + } else if (nextOperator.equalsIgnoreCase("Sine")) { + user.displayVal = MathMethods.sine(user.displayVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("Cosine")) { + user.displayVal = MathMethods.cosine(user.displayVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("Tangent")) { + user.displayVal = MathMethods.tan(user.displayVal); + Console.println("Your current total is %.2f", user.displayVal); + } else if (nextOperator.equalsIgnoreCase("Clear")) { + user.clearDisplayVal(); + break; + } + } + } } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MathMethods.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MathMethods.java new file mode 100644 index 00000000..85b330cb --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MathMethods.java @@ -0,0 +1,123 @@ +package com.zipcodewilmington.scientificcalculator; + +public class MathMethods { + //all math classes go here + + //Java Math Operators + + // Addition + + public static double add(double a, double b) { + double result = a + b; + return result; + } + + public static double subtract(double a, double b) { + double result1 = a - b; + return result1; + } + + public static double multiplication(double a, double b) { + double result2 = a * b; + return result2; + } + + public static double division(double a, double b) { + double result3 = a / b; + return result3; + } + + public static double remainder(double a, double b) { + double result4 = a % b; + return result4; + } + + public static double square(double a) { + double result6 = a * a; + return result6; + } + + public static double squareRoot(double a) { + double result7 = Math.sqrt(a); + return result7; + } + + public static double variExpo(double a, double b) { + double result7 = Math.pow(a, b); + return result7; + } + + public static double inverse(double a) { + double result = 1/a; + return result; + } + + public static double invert(double a) { + double result8 = a * -1; + return result8; + } + public static double sine(double a) { + double result9 = Math.sin(a); + return result9; + } + public static double cosine(double a) { + double result10 = Math.cos(a); + return result10; + } + public static double tan(double a) { + double result11 = Math.tan(a); + return result11; + } + + public static double absolute(double a) { + double result5 = Math.abs(a); + return result5; + } + + + +// public static double absolute(double a, double b) { +// double result5 = math.abs(); +// return result5; +// } + +// public static double Sine(Math.sin(input a)) +// //Math.cos() +// public static double Cosine { +// cos(double angle) + + +/* + //The Java Math Class + //Basic Math Functions + Math.abs() + Math.ceil() + Math.floor() + Math.floorDiv() + Math.min() + Math.max() + Math.round() + Math.random() + //Exponential and Logarithmic Math Functions + Math.exp() + Math.log() + Math.log10() + Math.pow() + Math.sqrt() + //Trigonometric Math Functions + Math.PI + +public static int Sine(Math.sin(input a)) + Math.cos() + Math.tan() + Math.asin() + Math.acos() + Math.atan() + Math.atan2() + Math.sinh() + Math.cosh() + Math.tanh() + Math.toDegrees() + Math.toRadians() +*/ +} diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 94e8d987..fa6b2d25 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -3,5 +3,139 @@ /** * Created by leon on 2/9/18. */ + +import com.zipcodewilmington.scientificcalculator.MathMethods; +import org.junit.Test; +import static org.junit.Assert.assertEquals; + public class TestMainApplication { + MathMethods test = new MathMethods(); + + @Test + public void addTest1() { + assertEquals(10, test.add(5, 5), 0.01); + } + + @Test + public void addTest2() { + assertEquals(10.5, test.add(7, 3.5), 0.01); + } + + @Test + public void subtractTest1() { + assertEquals(2, test.subtract(7, 5), 0.01); + } + + @Test + public void subtractTest2() { + assertEquals(10, test.subtract(20.5, 10.5), 0.01); + } + + @Test + public void multiplicationTest1() { + assertEquals(56, test.multiplication(7, 8), 0.01); + } + + @Test + public void multiplicationTest2() { + assertEquals(8.05, test.multiplication(2.3, 3.5), 0.01); + } + + @Test + public void divisionTest1() { + assertEquals(3, test.division(15, 5), 0.01); + } + + @Test + public void divisionTest2() { + assertEquals(6.0, test.division(36.0, 6.0), 0.01); + } + + @Test + public void remainderTest1() { + assertEquals(2.0, test.remainder(5.00, 3.00), 0.01); + ; + } + + @Test + public void remainderTest2() { + assertEquals(0.00, test.remainder(6.00, 3.00), 0.01); + ; + } + + @Test + public void squareTest1() { + assertEquals(36.00, test.square(6.00), 0.01); + ; + } + + @Test + public void squareTest2() { + assertEquals(9.00, test.square(3.00), 0.01); + ; + } + + @Test + public void squareRootTest1() { + assertEquals(5.00, test.squareRoot(25.00), 0.01); + ; + } + + @Test + public void squareRootTest2() { + assertEquals(9.00, test.squareRoot(81.00), 0.01); + ; + } + + @Test + public void variExpoTest1() { + assertEquals(49.00, test.variExpo(7.00, 2.00), 0.01); + + } + + @Test + public void variExpo1Test2() { + assertEquals(1000.00, test.variExpo(10.00, 3.00), 0.01); + + } + + @Test + public void invertTest1() { + assertEquals(-10.00, test.invert(10.00), 0.01); + } + + @Test + public void invertTest2() { + assertEquals(50.00, test.invert(-50.00), 0.01); + } + + @Test + public void sineTest1() { + assertEquals(-0.7568, test.sine(4.00), 0.01); + } + + @Test + public void sineTest2() { + assertEquals(0.9894, test.sine(8.00), 0.01); + } + + @Test + public void cosineTest1() { + assertEquals(-0.9899, test.cosine(3.00), 0.01); + } + + @Test + public void cosineTest2() { + assertEquals(0.7539, test.cosine(7.00), 0.01); + } + + @Test + public void tanTest1() { + assertEquals(-2.185, test.tan(2.00), 0.01); + } + + @Test + public void tanTest2() { + assertEquals(-225.95, test.tan(11.00), 0.01); + } }