diff --git a/SciCalc.puml b/SciCalc.puml new file mode 100644 index 0000000..f2cda62 --- /dev/null +++ b/SciCalc.puml @@ -0,0 +1,27 @@ +@startuml +'https://plantuml.com/class-diagram + +abstract class AbstractList +abstract AbstractCollection +interface List +interface Collection + +List <|-- AbstractList +Collection <|-- AbstractCollection + +Collection <|- List +AbstractCollection <|- AbstractList +AbstractList <|-- ArrayList + +class ArrayList { +Object[] elementData +size() +} + +enum TimeUnit { +DAYS +HOURS +MINUTES +} + +@enduml \ No newline at end of file diff --git a/ScienceCalc.puml b/ScienceCalc.puml new file mode 100644 index 0000000..9655887 --- /dev/null +++ b/ScienceCalc.puml @@ -0,0 +1,13 @@ +@startuml +'https://plantuml.com/object-diagram + +object Science.java +object Console + +map MainApp { + Calculator *-> Science.java + Welcome msg. *--> Console +} + +'NewYork --> CapitalCity::USA +@enduml diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 83f0e97..d917682 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -23,10 +23,19 @@ public static String getStringInput(String prompt) { } public static Integer getIntegerInput(String prompt) { - return null; + Scanner scanner = new Scanner(System.in); + System.out.println(prompt); + int userInput2= scanner.nextInt(); + return userInput2; } public static Double getDoubleInput(String prompt) { - return null; + Scanner scanner = new Scanner(System.in); + System.out.println(prompt); + while(!scanner.hasNextDouble()){ + System.out.println("Invalid input. Please enter a valid double"); + scanner.next(); + } + return scanner.nextDouble(); } -} +} \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Corefunctions.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Corefunctions.java new file mode 100644 index 0000000..107a4c3 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Corefunctions.java @@ -0,0 +1,4 @@ +package com.zipcodewilmington.scientificcalculator; + +public class Corefunctions { +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Customfunctions.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Customfunctions.java new file mode 100644 index 0000000..9a4d2ea --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Customfunctions.java @@ -0,0 +1,6 @@ +package com.zipcodewilmington.scientificcalculator; +import java.util.Scanner; + +public class Customfunctions { + +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f42132..d4e43ef 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,17 +1,147 @@ package com.zipcodewilmington.scientificcalculator; - +import java.util.Scanner; /** * 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); + System.out.println("Welcome to my scientific calculator"); + Scanner scanner = new Scanner(System.in); + double memory = 0; + + + while (true) { //SwitchDisplayMode(String mode) = allow user to type operation/menu options in + System.out.println(" Choose an operation"); + //.nextln()?? + System.out.println("1: Addition"); + System.out.println("2: Subtraction"); + System.out.println("3: Multiplication"); + System.out.println("4: Division"); + System.out.println("5: Square"); + System.out.println("6: Cube/Exponent"); + System.out.println("7: Square root"); + System.out.println("8: Sine"); + System.out.println("9: Cosine"); + System.out.println("10: Tangent"); + System.out.println("11: Inverse Sine"); + System.out.println("12: Inverse Cosine"); + System.out.println("13: Inverse Tangent"); + System.out.println("14: Inverse"); + System.out.println("15: Switch sign"); + System.out.println("16: Factorial"); + System.out.println("17: Degrees"); + System.out.println("18: Radians"); + System.out.println("19: log"); + System.out.println("20: log10"); + System.out.println("21: log1p"); + System.out.println("22: Inverse Natural Log"); + System.out.println("23:Store Memory"); + System.out.println("24:Reset Memory"); + System.out.println("25:Recall Memory"); + System.out.println("26: Quit application"); + //SwitchDisplayMode() = create multiple display menus instead of one large one? + + int choice = scanner.nextInt(); //Close scanner when all inputs are built + + if(choice == 26){ + break; + } + + double num1 = 0; + double num2 = 0; + + if(choice >=1 && choice <= 4 || choice ==6 || choice ==25){ + System.out.println("Enter first number: "); + num1=scanner.nextDouble(); + System.out.println("Enter second number: "); + num2=scanner.nextDouble(); + }else if (choice == 5 || choice == 7 || (choice >= 8 && choice <= 25)){ + num1= Console.getDoubleInput("Enter number here :"); + } + + + Science science = new Science(); + switch(choice){ + case 1: + System.out.println("Result:" + science.addition(num1, num2)); + break; + + case 2: + System.out.println("Result:" + science.subtraction(num1, num2)); + break; + case 3: + System.out.println("Result:" + science.multiplication(num1, num2)); + break; + case 4: + System.out.println("Result:" + science.division(num1, num2)); + break; + case 5: + System.out.println("Result:" + science.square(num1)); + break; + case 6: + System.out.println("Result:" + science.pow(num1, num2)); + break; + case 7: + System.out.println("Result:" + science.squareRt(num1)); + break; + case 8: + System.out.println("Result:" + science.sin(num1)); + break; + case 9: + System.out.println("Result:" + science.cos(num1)); + break; + case 10: + System.out.println("Result:" + science.tan(num1)); + break; + case 11: + System.out.println("Result:" + science.inverseSine(num1)); + break; + case 12: + System.out.println("Result:" + science.inverseCos(num1)); + break; + case 13: + System.out.println("Result:" + science.inverseTan(num1)); + break; + + case 14: + System.out.println("Result:" + science.inverse(num1)); + break; + case 15: + System.out.println("Result:" + science.switchSign(num1)); + break; + case 16: + System.out.println("Result:" + science.factorial((int) num1)); + break; + case 17: + System.out.println("Result:" + science.degrees(num1)); + break; + case 18: + System.out.println("Result:" + science.radians(num1)); + break; + case 19: + System.out.println("Result:" + science.log(num1)); + break; + case 20: + System.out.println("Result:" + science.log10(num1)); + break; + case 21: + System.out.println("Result:" + science.log1p(num1)); + break; + case 22: + System.out.println("Result:" + science.inverseNL(num1)); + break; + case 23: + System.out.println("Result:" + science.storeMemory(num1)); + break; + case 24: + System.out.println("Result:" + science.resetMemory(num1)); + break; + case 25: + System.out.println("Result:" + science.recallMemory(num1)); + break; + + } + } } } + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Science.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Science.java new file mode 100644 index 0000000..27b97c0 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Science.java @@ -0,0 +1,123 @@ +package com.zipcodewilmington.scientificcalculator; +import java.math.BigInteger; +import java.lang.Math; + + +public class Science { + + public static double square(double num){ + return num*num; + } + public static double pow(double a, double b){ + return Math.pow(a, b); + } + public static double squareRt(double num) { + return Math.sqrt(num); + } + public static double inverse(double num) { + return 1 / num; + } + + //If absolute value of number is greater than 1 the result will be NaN + public static double inverseSine(double num) { + return Math.asin(num); + } + + //Returns sign of number 1 for positive, -1 for negative and 0 for zero + public static double switchSign(double num) { + return Math.signum(num); + } + public static double sin(double num) { + return Math.sin(num); + } + public static double cos(double num) { + return Math.cos(num); + } + public static double tan(double num) { + return Math.tan(num); + } + public static double inverseCos(double num) { + return Math.acos(num); + } + public double inverseTan(double num) { + return Math.atan(num); + } + + //using BigInteger import + public static int factorial(int num) { + int solution = 1; + for (int i = 1; i <= num; i++) { + solution *= i; + } + return solution; + } + + //Addition + public static double addition(double a, double b) { + return a + b; + } + //Subtract + public static double subtraction(double a, double b) { + return a - b; + } + + //Multiplication + public static double multiplication(double a, double b) { + return a * b; + } + + //Division + public static double division(double a, double b) { + if (b == 0) { + throw new ArithmeticException("Can't divide by 0"); + } else { + return a / b; + } + } + + //Degrees + public static double degrees(double num) { + return (num * Math.PI) / 180; + } + + //Radians + public static double radians(double num) { + return (num * 180) / (Math.PI); + } + + //Log + public static double log(double num) { + return Math.log(num); + + } + + //Inverse Log + public static double log10(double num) { + return Math.log10(num); + } + + //Natural logarithm + public static double log1p(double num) { + return Math.log1p(num); + } + //Inverse Natural Log + public static double inverseNL(double num) { + return (Math.exp(Math.log(num))); + } + + //Store memory + public static double storeMemory(double a){ + return a; + } + //reset memory + public static double resetMemory(double a){ + return a = 0; + } + //recall memory + public static double recallMemory(double a){ + return a; + } + +} + + diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/ScienceTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/ScienceTest.java new file mode 100644 index 0000000..58e1922 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/ScienceTest.java @@ -0,0 +1,271 @@ +package com.zipcodewilmington.scientific_calculator; + +import com.zipcodewilmington.scientificcalculator.Science; +import org.junit.Test; + +import static java.lang.Double.NaN; +import static org.junit.Assert.assertEquals; + +public class ScienceTest { + + @Test + + public void testsquare1() { + Science science1 = new Science(); + double actual = science1.square(9.0); + assertEquals(81, actual, 0.001); + } + + @Test + public void testsquare2() { + Science science1 = new Science(); + double actual = science1.square(4); + assertEquals(16, actual, 0.001); + } + + @Test + public void testsquare3() { + Science science1 = new Science(); + double actual = science1.square(12); + assertEquals(144.0, actual, 0.001); + } + + @Test + public void testsquareRt() { + Science science1 = new Science(); + double actual = science1.squareRt(25); + assertEquals(5, actual, 0.001); + } + + @Test + public void testlog() { + Science science1 = new Science(); + double actual = science1.log(10); + assertEquals(2.302585092994046, actual, 0.001); + } + + @Test + public void testfactorial() { + Science science1 = new Science(); + int actual = science1.factorial(5); + assertEquals(120.0, actual, 0001); + } + + @Test + public void testsin() { + Science science1 = new Science(); + double actual = science1.sin(20); + assertEquals(0.9129452507276277, actual, 0.001); + } + + @Test + public void testpow() { + Science science1 = new Science(); + double actual = science1.pow(5, 4); + assertEquals(625, actual, 0.001); + }@Test + public void testpow2() { + Science science1 = new Science(); + double actual = science1.pow(6, 6); + assertEquals(46656, actual, 0.001); + } + + @Test + public void testadd(){ + Science science1 = new Science(); + double actual = science1.addition(10, 2); + assertEquals(12, actual , 0.001); + } @Test + public void testadd2(){ + Science science1 = new Science(); + double actual = science1.addition(25, 25); + assertEquals(50, actual , 0.001); + } + + @Test + public void testinverseCos(){ + Science science1 = new Science(); + double actual = science1.inverseCos(2); + assertEquals(NaN, actual, 0.0001); + }@Test + public void testinverseCos2(){ + Science science1 = new Science(); + double actual = science1.inverseCos(6); + assertEquals(NaN, actual, 0.0001); + } + @Test + public void testinverse(){ + Science science1 = new Science(); + double actual = science1.inverse(10); + assertEquals(0.1, actual , 0.000001); + }@Test + public void testinverse2(){ + Science science1 = new Science(); + double actual = science1.inverse(50); + assertEquals(0.02, actual , 0.000001); + } + + @Test + public void testinverseSine(){ + Science science1 = new Science(); + double actual = science1.inverseSine(10); + assertEquals(NaN, actual , 0.000001); + }@Test + public void testinverseSine2(){ + Science science1 = new Science(); + double actual = science1.inverseSine(15); + assertEquals(NaN, actual , 0.000001); + } + + @Test + public void testswitchSign(){ + Science science1 = new Science(); + double actual = science1.switchSign(10); + assertEquals(1, actual , 0.000001); + }@Test + public void testswitchSign2(){ + Science science1 = new Science(); + double actual = science1.switchSign(15); + assertEquals(1, actual , 0.000001); + } + + @Test + public void testcos(){ + Science science1 = new Science(); + double actual = science1.cos(10); + assertEquals(-0.8390715290764524, actual , 0.000001); + } @Test + public void testcos5(){ + Science science1 = new Science(); + double actual = science1.cos(20); + assertEquals(0.40808206181339196, actual , 0.000001); + } + + @Test + public void testtan(){ + Science science1 = new Science(); + double actual = science1.tan(10); + assertEquals(0.6483608274590866, actual , 0.000001); + }@Test + public void testtan2(){ + Science science1 = new Science(); + double actual = science1.tan(30); + assertEquals(-6.405331196646276, actual , 0.000001); + } + + @Test + public void testinversetan(){ + Science science1 = new Science(); + double actual = science1.inverseTan(3); + assertEquals(1.2490457723982544, actual , 0.000001); + }@Test + public void testinversetan2(){ + Science science1 = new Science(); + double actual = science1.inverseTan(8); + assertEquals(1.446441332248135, actual , 0.000001); + } + + @Test + public void testsub(){ + Science science1 = new Science(); + double actual = science1.subtraction(3, 10); + assertEquals(-7, actual , 0.000001); + } + @Test + public void testsub1(){ + Science science1 = new Science(); + double actual = science1.subtraction(10, 3); + assertEquals(7, actual , 0.000001); + } + + @Test + public void testmulti(){ + Science science1 = new Science(); + double actual = science1.multiplication(-3, 10); + assertEquals(-30, actual , 0.000001); + }@Test + public void testmulti2(){ + Science science1 = new Science(); + double actual = science1.multiplication(13, 113); + assertEquals(1469.0, actual , 0.000001); + } + + @Test + public void testdivision(){ //test will throw + // ArithmeticException("Can't divide by 0") if dividing by zero + Science science1 = new Science(); + double actual = science1.division(-3, 10); + assertEquals(-0.3, actual , 0.000001); + }@Test + public void testdivision2(){ //test will throw + // ArithmeticException("Can't divide by 0") if dividing by zero + Science science1 = new Science(); + double actual = science1.division(50, 10); + assertEquals(5, actual , 0.000001); + } + + @Test + public void testdegrees(){ + Science science1 = new Science(); + double actual = science1.degrees(10); + assertEquals(0.17453292519943295, actual , 0.000001); + } @Test + public void testdegrees2(){ + Science science1 = new Science(); + double actual = science1.degrees(100); + assertEquals(1.7453292519943295, actual , 0.000001); + } + + @Test + public void testlog10(){ + Science science1 = new Science(); + double actual = science1.log10(5); + assertEquals(0.6989700043360189, actual , 0.000001); + } + + @Test + public void testlog1p(){ + Science science1 = new Science(); + double actual = science1.log1p(5); + assertEquals(1.791759469228055, actual , 0.000001); + }@Test + public void testlog1p2(){ + Science science1 = new Science(); + double actual = science1.log1p(25); + assertEquals(3.258096538021482, actual , 0.000001); + } + + @Test + public void testinverseNL(){ + Science science1 = new Science(); + double actual = science1.inverseNL(5); + assertEquals(5, actual , 0.000001); + }@Test + public void testinverseNL2(){ + Science science1 = new Science(); + double actual = science1.inverseNL(73); + assertEquals(72.99999999999999, actual , 0.000001); + } + @Test + public void testradians(){ + Science science1 = new Science(); + double actual = science1.radians(10); + assertEquals(572.9577951308232, actual , 0.000001); + }@Test + public void testradians2(){ + Science science1 = new Science(); + double actual = science1.radians(42); + assertEquals(2406.4227395494577, actual , 0.000001); + } + + + + + + + +} + + + + diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 94e8d98..6cec4ac 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -4,4 +4,5 @@ * Created by leon on 2/9/18. */ public class TestMainApplication { + }