diff --git a/pom.xml b/pom.xml index b92b052..cdf84d9 100644 --- a/pom.xml +++ b/pom.xml @@ -25,29 +25,14 @@ - - org.apache.maven.plugins - maven-compiler-plugin - 3.8.1 - - - junit - junit - 4.12 - test - + junit junit - 4.12 - test - - - junit - junit - 4.12 + 4.13.2 test + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 83f0e97..552492a 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -7,6 +7,11 @@ */ public class Console { + public static void defaultValue (){ + System.out.println(SimpleCalculator.intResult); + } + + public static void print(String output, Object... args) { System.out.printf(output, args); } @@ -22,11 +27,17 @@ public static String getStringInput(String prompt) { return userInput; } - public static Integer getIntegerInput(String prompt) { - return null; + public static Integer getIntegerInput() { + Scanner scan = new Scanner(System.in); + int number = scan.nextInt(); + return number; } - public static Double getDoubleInput(String prompt) { - return null; + public static Double getDoubleInput() { + Scanner scan = new Scanner(System.in); + double d = scan.nextDouble(); + return d; } + + } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f42132..555b44d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -4,14 +4,35 @@ * 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.defaultValue(); +// 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 double", d); +// +// +// +//// SimpleCalculator simpleCalculation = new SimpleCalculator(); +//// double dd = simpleCalculation.calculator('*',i,d); +// +// +// +// System.out.println("Result = "+ScientificCalculator.cosine(d)); + + StartCalculatorWithType.start(); + + + + + + - 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); } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalculator.java new file mode 100644 index 0000000..3e89ec8 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalculator.java @@ -0,0 +1,61 @@ +package com.zipcodewilmington.scientificcalculator; + +public class ScientificCalculator { + + public double square(double x){ + return x * x; + } + + public double squareRoot(double x){ + return Math.sqrt(x); + } + + public double inverse(double x) { + return 1 / x; + } + + public double switchSign(double x) { + return -x; + } + + public double sine(double x) { + return Math.sin(x); + } + + public double cosine(double x) { + return Math.cos(x); + } + + public double tangent(double x) { + return Math.tan(x); + } + + public double inverseSine(double x) { + return Math.asin(x); + } + + public double inverseCosine(double x) { + return Math.acos(x); + } + + public double inverseTangent(double x) { + return Math.atan(x); + } + + public double factorial(double x) { + if (x == 0) { + return 1; + } + else{ + int result = 1; + for (int i = 1;i<=x;i++){ + result*=i; + } + return result; + } + + } + + + +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/SimpleCalculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/SimpleCalculator.java new file mode 100644 index 0000000..0dcd42a --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/SimpleCalculator.java @@ -0,0 +1,150 @@ +package com.zipcodewilmington.scientificcalculator; + +public class SimpleCalculator { + + + public static double doubleResult; + public static int intResult; + + public SimpleCalculator(){ + this.intResult = 0; + } + + + public double calculator(char operator, double num1, double num2) { + + if (operator == '+') { + doubleResult = num1 + num2; + } + + + else if (operator == '-') { + if (num1 > num2) { + doubleResult = num1 - num2; + } else { + doubleResult = -num2 -(- num1); + } + } + else if (operator == '*') { + if(num1<0 || num2<0){ + doubleResult = -num1 * num2; + } + else { + doubleResult = num1 * num2; + } + + } + else if (operator == '%') { + doubleResult = num1 % num2; + } + else { + try { + + doubleResult = num1 / num2; + + + } catch (ArithmeticException e) { + System.out.println("Error " + e.getMessage()); + } + + } + return doubleResult; + } + + + + public double calculator(char operator, int num1, double num2) { + if (operator == '+') { + doubleResult = num1 + num2; + } else if (operator == '-') { + if (num1 > num2) { + doubleResult = num1 - num2; + } else { + doubleResult = num2 - num1; + } + } + else if (operator == '%') { + doubleResult = num1 % num2; + } + else if (operator == '*') { + doubleResult = num1 * num2; + } else { + try { + doubleResult = num1 / num2; + + } catch (ArithmeticException e) { + System.out.println("Exception handled " + e.getMessage()); + } + + } + return doubleResult; + } + + public double calculator(char operator, double num1, int num2) { + if (operator == '+') { + doubleResult = num1 + num2; + } else if (operator == '-') { + if (num1 > num2) { + doubleResult = num1 - num2; + } + else if (operator == '%') { + doubleResult = num1 % num2; + } + else { + doubleResult = num2 - num1; + } + } + else if (operator == '*') { + doubleResult = num1 * num2; + } else { + try { + + doubleResult = num1 / num2; + + } catch (ArithmeticException e) { + System.out.println("Exception handled " + e.getMessage()); + } + + } + return doubleResult; + } + + public double calculator(char operator, int num1, int num2) { + if (operator == '+') { + doubleResult = num1 + num2; + } else if (operator == '-') { + if (num1 > num2) { + doubleResult = num1 - num2; + } + else { + doubleResult = num2 - num1; + } + } else if (operator == '*') { + doubleResult = num1 * num2; + } + + else if (num1 > num2) { + try{ + doubleResult = num1 / num2; + } + catch (ArithmeticException e){ + System.out.println("Can't divide by zero"); + } + + + } + else if (num2 < num1) { + try{ + doubleResult = num2 / num1; + } + catch (ArithmeticException e){ + return Double.parseDouble("Error"); + } + } + + return doubleResult; + + + + } +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/StartCalculatorWithType.java b/src/main/java/com/zipcodewilmington/scientificcalculator/StartCalculatorWithType.java new file mode 100644 index 0000000..dce14f5 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/StartCalculatorWithType.java @@ -0,0 +1,98 @@ +package com.zipcodewilmington.scientificcalculator; + +import java.util.Scanner; + +public class StartCalculatorWithType { + + static SimpleCalculator sm = new SimpleCalculator(); + static ScientificCalculator sf = new ScientificCalculator(); + public static void start(){ + Scanner scan = new Scanner(System.in); + System.out.println("Please choose a calculator type:"); + System.out.println("Please enter 1 for Simple calculator"); + System.out.println("Please enter 2 for Scientific calculator"); + + int num = scan.nextInt(); + + if(num==1){ + + System.out.println("Please enter operator"); + System.out.println("" + + "addition(+) " + + "subtraction(-) " + + "division(/) " + + "multiplication(*) " + + "modulus(%) "); + + char ch = scan.next().charAt(0); + System.out.println("Please enter first number"); + double dub1 = scan.nextDouble(); + System.out.println("Please enter second number"); + double dub2 = scan.nextDouble(); + System.out.println("Result "+ sm.calculator(ch,dub1,dub2)); + } + + else { + System.out.println("You entered scientific calculator"); + System.out.println("Please enter value"); + double value = scan.nextDouble(); + System.out.println("Please choose calculation method"); + System.out.println("" + + "1-square, " + + "2-squareRoot, " + + "3-inverse, " + + "4-switchSign " + + "5-sine " + + "6-cosine " + + "7-tangent " + + "8-inverseSine " + + "9-inverseCosine " + + "10-inverseTangent " + + "11-factorial "); + int a = scan.nextInt(); + + switch (a){ + case 1: + System.out.println("Result: "+sf.square(value)); + break; + case 2: + System.out.println("Result: "+sf.squareRoot(value)); + break; + case 3: + System.out.println("Result: "+sf.inverse(value)); + break; + case 4: + System.out.println("Result "+sf.switchSign(value)); + + break; + case 5: + System.out.println("Result " + sf.sine(value)); + break; + case 6: + System.out.println("Result "+sf.cosine(value)); + break; + case 7: + System.out.println("Result "+sf.tangent(value)); + break; + case 8: + System.out.println("Result "+sf.inverseSine(value)); + break; + case 9: + System.out.println("Result "+sf.inverseCosine(value)); + break; + case 10: + System.out.println("Result "+sf.inverseTangent(value)); + break; + case 11: + System.out.println("Result "+sf.factorial(value)); + + } + } + + + + + } + + +} diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 94e8d98..98d5e12 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,7 +1,95 @@ package com.zipcodewilmington.scientific_calculator; -/** - * Created by leon on 2/9/18. - */ +import com.zipcodewilmington.scientificcalculator.ScientificCalculator; +import com.zipcodewilmington.scientificcalculator.SimpleCalculator; +import org.junit.Test; + +import static java.lang.Double.isNaN; +import static org.junit.Assert.assertEquals; + +//Created By Alice Gonzalez public class TestMainApplication { + SimpleCalculator simpleCalculator = new SimpleCalculator(); + + @Test + public void addition_Test(){ + assertEquals(8.0,simpleCalculator.calculator('+',3.0,5.0),0.0001); + } + + @Test + public void multiplication_Test() { + assertEquals(42.0,simpleCalculator.calculator('*',7.0,6.0),0.0001); + } + + @Test + public void division_Test() { + assertEquals(4.5,simpleCalculator.calculator('/',63.0,14.0),0.0001); + } + + @Test + public void percentage_Test() { + assertEquals(7.0,simpleCalculator.calculator('-',9.0,2.0),0.0001); + } + @Test + public void subtraction_Test() { + assertEquals(-7.0,simpleCalculator.calculator('-',7.0,14.0),0.0001); + } + ScientificCalculator scientificCalculator = new ScientificCalculator(); + + @Test + public void square_Test() { + assertEquals(9.61,scientificCalculator.square(3.1), 0.0001); + } + + @Test + public void squareRoot_Test() { + assertEquals(2.6832,scientificCalculator.squareRoot(7.2), 0.0001); + } + + @Test + public void inverse_Test() { + assertEquals(0.1851,scientificCalculator.inverse(5.4) , 0.0001); + } + + @Test + public void switchSign_Test() { + assertEquals(-5.00, scientificCalculator.switchSign(5.00), 0.0001); + + assertEquals( 6.53,scientificCalculator.switchSign(-6.53) , 0.0001); + } + + @Test + public void sine_Test() { + assertEquals(-0.8834,scientificCalculator.sine(5.2) , 0.0001); + } + + @Test + public void cosine_Test() { + assertEquals(0.9931,scientificCalculator.cosine(6.4) , 0.0001); + } + + @Test + public void tangent_Test() { + assertEquals(-5.2674,scientificCalculator.tangent(4.9) , 0.0001); + } + + @Test + public void inverseSine_Test() { + assertEquals(0.2526,scientificCalculator.inverseSine(0.25) , 0.0001); + } + + @Test + public void inverseCosine_Test() { + assertEquals(2.0409,scientificCalculator.inverseCosine(-0.453) , 0.0001); + } + @Test + public void inverseTangent_Test() { + assertEquals(-0.4281,scientificCalculator.inverseTangent(-0.4564) , 0.0001); + } + + @Test + public void factorial_Test() { + assertEquals(720,scientificCalculator.factorial(6) , 0.0001); + } + }