diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..e3f0354 Binary files /dev/null and b/.DS_Store differ diff --git a/README.md b/README.md index 40cc253..cd6957b 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,4 @@ + # ScientificCalculator (maven) ZCW diff --git a/Scientific Calculator.pdf b/Scientific Calculator.pdf new file mode 100644 index 0000000..6ee7a09 Binary files /dev/null and b/Scientific Calculator.pdf differ diff --git a/pom.xml b/pom.xml index e7cb4f6..709a27c 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,10 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + 18 + 18 + \ No newline at end of file diff --git a/src/.DS_Store b/src/.DS_Store new file mode 100644 index 0000000..bfe0f3b Binary files /dev/null and b/src/.DS_Store differ diff --git a/src/.idea/.gitignore b/src/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/src/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/src/.idea/misc.xml b/src/.idea/misc.xml new file mode 100644 index 0000000..e3a9e45 --- /dev/null +++ b/src/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/src/.idea/modules.xml b/src/.idea/modules.xml new file mode 100644 index 0000000..31eaf94 --- /dev/null +++ b/src/.idea/modules.xml @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/src/.idea/uiDesigner.xml b/src/.idea/uiDesigner.xml new file mode 100644 index 0000000..2b63946 --- /dev/null +++ b/src/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/.idea/vcs.xml b/src/.idea/vcs.xml new file mode 100644 index 0000000..6c0b863 --- /dev/null +++ b/src/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/src/main/.DS_Store b/src/main/.DS_Store new file mode 100644 index 0000000..559f94e Binary files /dev/null and b/src/main/.DS_Store differ diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store new file mode 100644 index 0000000..6caecfd Binary files /dev/null and b/src/main/java/.DS_Store differ diff --git a/src/main/java/com/.DS_Store b/src/main/java/com/.DS_Store new file mode 100644 index 0000000..e5728ca Binary files /dev/null and b/src/main/java/com/.DS_Store differ diff --git a/src/main/java/com/zipcodewilmington/.DS_Store b/src/main/java/com/zipcodewilmington/.DS_Store new file mode 100644 index 0000000..bb7ffc3 Binary files /dev/null and b/src/main/java/com/zipcodewilmington/.DS_Store differ diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 83f0e97..109fe0e 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -1,5 +1,7 @@ package com.zipcodewilmington.scientificcalculator; + +import java.util.InputMismatchException; import java.util.Scanner; /** @@ -7,26 +9,225 @@ */ public class Console { - public static void print(String output, Object... args) { - System.out.printf(output, args); - } + private boolean onButton; + private double firstNumber; + private double secondNumber; + private String operator; - public static void println(String output, Object... args) { - print(output + "\n", args); - } - public static String getStringInput(String prompt) { - Scanner scanner = new Scanner(System.in); - println(prompt); - String userInput = scanner.nextLine(); - return userInput; - } + public void calcRun() { + + + onButton = true; + Scanner Calculator = new Scanner(System.in); + + Scanner inputEsc = new Scanner(System.in); + Console reRun = new Console(); + + while (onButton) { + // loop wrong operator true + // print for operator choices + System.out.println("Type the function within the ()."); + System.out.println("For addition(+), subtraction(-), division(/), or multiplication(*)"); + System.out.println("For the square(**), square-root(**/), cube(***), cube-root(***/), switch-sign(+/-) or factorial(fac)"); + System.out.println("For the inverse, sine, cosine, tan, invsine, invcosine or invtangent, write as they are presented"); + + System.out.println(); + // print enter number + System.out.print("Enter first number "); + + // try catch method for first number + + try { + firstNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + reRun.calcRun(); + } + System.out.println("Enter math operator to use for this calculation"); + + // try catch method for operator + operator = Calculator.next(); - public static Integer getIntegerInput(String prompt) { - return null; - } - public static Double getDoubleInput(String prompt) { - return null; + // switch statement for the operator + switch (operator) { + case "+": + CoreFeatures additionFormula = new CoreFeatures(); + //try catch method for second number + System.out.print("Enter second number "); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } + String additionFormulaRead = String.valueOf(additionFormula.add(firstNumber, secondNumber)); + System.out.println(additionFormulaRead); + break; + case "-": + CoreFeatures subtractionFormula = new CoreFeatures(); + //try catch method for second number + System.out.print("Enter second number "); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } + String subtractionFormulaRead = String.valueOf(subtractionFormula.subtract(firstNumber, secondNumber)); + System.out.println(subtractionFormulaRead); + break; + case "/": + CoreFeatures divisionFormula = new CoreFeatures(); + //try catch method for second number + System.out.print("Enter second number "); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } + String divisionFormulaRead = String.valueOf(divisionFormula.div(firstNumber, secondNumber)); + System.out.println(divisionFormulaRead); + break; + case "*": + CoreFeatures multiplyFormula = new CoreFeatures(); + //try catch method for second number + System.out.print("Enter second number "); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } + String multiplyFormulaRead = String.valueOf(multiplyFormula.mult(firstNumber, secondNumber)); + System.out.println(multiplyFormulaRead); + break; + case "**": + ScientificFeatures squareFormula = new ScientificFeatures(); + String squareFormulaPrint = String.valueOf(squareFormula.square(firstNumber)); + System.out.println(squareFormulaPrint); + break; + case "***": + CubeFeatures cubeFormula = new CubeFeatures(); + String cubeFormulaPrint = String.valueOf(cubeFormula.cube(firstNumber)); + System.out.println(cubeFormulaPrint); + break; + case "***/": + CubeRootFeatures cubeRtFormula = new CubeRootFeatures(); + String cubeRtFormulaPrint = String.valueOf(cubeRtFormula.cubeRoot(firstNumber)); + System.out.println(cubeRtFormulaPrint); + break; + case "+/-": + ScientificFeatures switchSignFormula = new ScientificFeatures(); + String switchSignFormulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); + System.out.println(switchSignFormulaRead); + break; + case "**/": + ScientificFeatures squareRootFormula = new ScientificFeatures(); + String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); + System.out.println(squareRootFormulaPrint); + break; + case "inverse": + ScientificFeatures inverseFormula = new ScientificFeatures(); + String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); + if(inverseFormula.equals("0")) + try { + System.out.println(inverseFormulaRead); + } catch (Exception e) { + System.out.println("Err"); + + } + break; + case "sine": + ScientificFeatures sineFormula = new ScientificFeatures(); + String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); + System.out.println(sineFormulaRead); + break; + case "cos": + ScientificFeatures cosineFormula = new ScientificFeatures(); + String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); + System.out.println(cosineFormulaRead); + break; + case "tan": + ScientificFeatures tanFormula = new ScientificFeatures(); + String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); + System.out.println(tanFormulaRead); + break; + case "invsine": + ScientificFeatures arcSine = new ScientificFeatures(); + //try catch method for second number + System.out.print("Enter second number "); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } + String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); + System.out.println(arcSineRead); + break; + case "invcosine": + ScientificFeatures arcCosine = new ScientificFeatures(); + //try catch method for second number + System.out.print("Enter second number "); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } + String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); + System.out.println(arcCosineRead); + break; + case "invtangent": + ScientificFeatures arcTan = new ScientificFeatures(); + //try catch method for second number + System.out.print("Enter second number "); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } + String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); + System.out.println(arcTanFormula); + break; + case "fac": + ScientificFeatures factorialFormula = new ScientificFeatures(); + String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); + System.out.println(factorialFormulaRead); + break; + default: + System.out.println("Incorrect operator"); + // Exit code + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + reRun.calcRun(); + } else { + System.out.println("Please enter the correct letter"); + } + break; + } + + // Exit Code + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + reRun.calcRun(); + } else { + System.out.println("Please enter the correct letter"); + } + } + } + } + + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java new file mode 100644 index 0000000..924b5a7 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java @@ -0,0 +1,32 @@ +package com.zipcodewilmington.scientificcalculator; + + +public class CoreFeatures { + + //Addition + public double add(double number1, double number2) { + + return number1 + number2; + } + + + //Subtraction + public double subtract(double number1, double number2) { + + return number1 - number2; + } + + + //Multiplication + public double mult(double number1, double number2) { + + return number1 * number2; + } + + //Division + public double div(double number1, double number2) { + + return number1 / number2; + } +} + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java new file mode 100644 index 0000000..498c038 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java @@ -0,0 +1,11 @@ +package com.zipcodewilmington.scientificcalculator; + +public class CubeFeatures { + private double result; + + public double cube(double number1) { + result = number1 * number1 * number1; + return result; + } + +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.java new file mode 100644 index 0000000..a2a89a2 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.java @@ -0,0 +1,12 @@ +package com.zipcodewilmington.scientificcalculator; + +public class CubeRootFeatures { + + private double result; + + public double cubeRoot(double num1) { + result = Math.cbrt(num1); + return result; + } + +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f42132..3472a87 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,17 +1,20 @@ package com.zipcodewilmington.scientificcalculator; + /** * 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); + + Console start = new Console(); + start.calcRun(); + + } + } + + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java new file mode 100644 index 0000000..c1e1360 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -0,0 +1,104 @@ +package com.zipcodewilmington.scientificcalculator; + + +public class ScientificFeatures { + private double result; + + + public double square(double num1) { + result = num1 * num1; + return result; + } + + public double squareRoot(double num1) { + result = Math.sqrt(num1); + return result; + } + + public double switchSign(double num1) { + result = num1 * -1; + return result; + } + + public double inverse(double num1) { + result = 1 / num1; + if (num1 == 0) { + System.out.println("Err"); + } else { + return result; + } + return result; + + } + + + public double sine(double num1) { + result = Math.sin(Math.toRadians(num1)); + return result; + } + + public double cos(double num1) { + result = Math.cos(Math.toRadians(num1)); + return result; + } + + public double tan(double num1) { + result = Math.tan(Math.toRadians(num1)); + return result; + } + + public double inverseSine(double opposite, double hypotenuse) { + //Talk to group about this one + result = Math.asin(opposite / hypotenuse); + return result; + } + + public double inverseCosine(double adjacent, double hypotenuse) { + // Talk to group about this one + result = Math.acos(adjacent / hypotenuse); + return result; + } + + public double inverseTangent(double opposite, double adjacent) { + // Talk to group about this one + result = Math.atan(opposite / adjacent); + return result; + } + + public double factorial(double num1) { + // Talk to group about this code + result = 1; + if (num1 < 0) { + System.out.println("You cannot get a factorial of a negative number"); + } else if (num1 >= 0) { + for (int i = 1; i < num1; i++) { + result += result * i; + } + } + return result; + } + + public double log(double num1) { + result = Math.log10(num1); + return result; + + } + + public double inverseLog(double num1) { + result = Math.pow(10, num1); + return result; + } + + public double ln(double num1) { + // Talk to group + result = Math.log(num1); + return result; + } + + public double inverseLn(double num1) { + result = Math.pow(Math.E, num1); + return result; + } + + +} diff --git a/src/out/.DS_Store b/src/out/.DS_Store new file mode 100644 index 0000000..a3eec16 Binary files /dev/null and b/src/out/.DS_Store differ diff --git a/src/out/production/.DS_Store b/src/out/production/.DS_Store new file mode 100644 index 0000000..24fb67d Binary files /dev/null and b/src/out/production/.DS_Store differ diff --git a/src/out/production/main/.DS_Store b/src/out/production/main/.DS_Store new file mode 100644 index 0000000..6caecfd Binary files /dev/null and b/src/out/production/main/.DS_Store differ diff --git a/src/out/production/main/com/.DS_Store b/src/out/production/main/com/.DS_Store new file mode 100644 index 0000000..e5728ca Binary files /dev/null and b/src/out/production/main/com/.DS_Store differ diff --git a/src/out/production/main/com/zipcodewilmington/.DS_Store b/src/out/production/main/com/zipcodewilmington/.DS_Store new file mode 100644 index 0000000..571c6e9 Binary files /dev/null and b/src/out/production/main/com/zipcodewilmington/.DS_Store differ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class new file mode 100644 index 0000000..9b1d1e6 Binary files /dev/null and b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class differ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class new file mode 100644 index 0000000..0e23e64 Binary files /dev/null and b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class differ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeFeatures.class new file mode 100644 index 0000000..61e9976 Binary files /dev/null and b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeFeatures.class differ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.class new file mode 100644 index 0000000..841f745 Binary files /dev/null and b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.class differ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class new file mode 100644 index 0000000..f47854f Binary files /dev/null and b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class differ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class new file mode 100644 index 0000000..3b01dda Binary files /dev/null and b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class differ diff --git a/src/out/test/test/com/zipcodewilmington/scientific_calculator/TestMainApplication.class b/src/out/test/test/com/zipcodewilmington/scientific_calculator/TestMainApplication.class new file mode 100644 index 0000000..9add06d Binary files /dev/null and b/src/out/test/test/com/zipcodewilmington/scientific_calculator/TestMainApplication.class differ diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.class new file mode 100644 index 0000000..1fec4e7 Binary files /dev/null and b/src/out/test/test/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.class differ diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.class new file mode 100644 index 0000000..813e085 Binary files /dev/null and b/src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.class differ diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeRootFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeRootFeaturesTest.class new file mode 100644 index 0000000..e08be1c Binary files /dev/null and b/src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeRootFeaturesTest.class differ diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class new file mode 100644 index 0000000..ba275cc Binary files /dev/null and b/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class differ diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 94e8d98..d78234d 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,7 +1,13 @@ package com.zipcodewilmington.scientific_calculator; +import com.zipcodewilmington.scientificcalculator.ScientificFeatures; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + /** * Created by leon on 2/9/18. */ public class TestMainApplication { + + } diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java new file mode 100644 index 0000000..4c9e95e --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java @@ -0,0 +1,36 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class CoreFeaturesTest { + + CoreFeatures allTests = new CoreFeatures(); + + + @Test + void subtractTest() { + double subT = allTests.subtract(5, 10); + Assertions.assertEquals(-5.0, subT); + } + + @Test + void addTest() { + double addT = allTests.add(5, 10); + Assertions.assertEquals(15.0, addT); + } + + @Test + void multTest() { + double multT = allTests.mult(5, 10); + Assertions.assertEquals(50.0, multT); + } + + @Test + void divTest() { + double divT = allTests.div(4, 6); + Assertions.assertEquals(0, divT); + } +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.java new file mode 100644 index 0000000..d84e344 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.java @@ -0,0 +1,18 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Assert; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class CubeFeaturesTest { + + @Test + public void testCube() { + CubeFeatures objCalcUnderTest = new CubeFeatures(); + double number1 = 2; + double expectedResult = 8; + double result = objCalcUnderTest.cube(number1); + Assert.assertEquals(expectedResult, result, 0.010); + } +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/CubeRootFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/CubeRootFeaturesTest.java new file mode 100644 index 0000000..ad9ede8 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/CubeRootFeaturesTest.java @@ -0,0 +1,18 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Assert; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class CubeRootFeaturesTest { + + @Test + public void testCubeRoot() { + CubeRootFeatures objCalcUnderTest = new CubeRootFeatures(); + double number1 = 9; + double expectedResult = 2.080083823051904; + double result = objCalcUnderTest.cubeRoot(number1); + Assert.assertEquals(expectedResult, result, 0.010); + } +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java new file mode 100644 index 0000000..db14c1c --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java @@ -0,0 +1,126 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Assert; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import static org.junit.Assert.assertEquals; + +import static org.junit.jupiter.api.Assertions.*; + +public class ScientificFeaturesTest { + + + @Test + void TestSquare() { + ScientificFeatures squareTest = new ScientificFeatures(); + double squareT = squareTest.square(5); + Assertions.assertEquals(25.0, squareT); + } + + @Test + void TestSquareRoot() { + ScientificFeatures squareRootTest = new ScientificFeatures(); + double squareT = squareRootTest.squareRoot(25); + Assertions.assertEquals(5.0, squareT); + } + + @Test + void TestSwitchSign() { + ScientificFeatures switchSignSwitch = new ScientificFeatures(); + double switchSignT = switchSignSwitch.switchSign(5); + Assertions.assertEquals(-5.0, switchSignT); + + } + + @Test + void TestInverse() { + ScientificFeatures inverseTest = new ScientificFeatures(); + double inverseT = inverseTest.inverse(5); + Assertions.assertEquals(0.20, inverseT); + + } + + + @Test + void TestSine() { + ScientificFeatures sineTest = new ScientificFeatures(); + double sineT = sineTest.sine(5); + Assertions.assertEquals(0.08715574274765817, sineT); + } + + @Test + void TestCos() { + ScientificFeatures cosineTest = new ScientificFeatures(); + double cosineT = cosineTest.cos(5); + Assertions.assertEquals(0.9961946980917455, cosineT); + + } + + @Test + void TestTan() { + ScientificFeatures tanTest = new ScientificFeatures(); + double tanT = tanTest.tan(5); + Assertions.assertEquals(0.087488663525924, tanT); + } + + @Test + void TestInverseSine() { + ScientificFeatures inverseSineTest = new ScientificFeatures(); + double inverseSineT = inverseSineTest.inverseSine(50, 110); + Assertions.assertEquals(0.47186183727964187, inverseSineT); + } + + @Test + void TestInverseCosine() { + ScientificFeatures inverseCosineTest = new ScientificFeatures(); + double inverseCosineT = inverseCosineTest.inverseCosine(50, 110); + Assertions.assertEquals(1.0989344895152549, inverseCosineT); + } + + @Test + void TestInverseTangent() { + ScientificFeatures inverseTangentTest = new ScientificFeatures(); + double inverseTangentT = inverseTangentTest.inverseTangent(50, 110); + Assertions.assertEquals(0.4266274931268761, inverseTangentT); + } + + @Test + void TestFactorial() { + ScientificFeatures factorialTest = new ScientificFeatures(); + double factorialT = factorialTest.factorial(5); + Assertions.assertEquals(120, factorialT); + } + + @Test + void TestLog() { + ScientificFeatures logTest = new ScientificFeatures(); + double logT = logTest.log(5); + Assertions.assertEquals(0.6989700043360189, logT); + + } + + @Test + void TestInverseLog() { + ScientificFeatures inverseLogTest = new ScientificFeatures(); + double inverseLogT = inverseLogTest.inverseLog(5); + Assertions.assertEquals(100000.0, inverseLogT); + } + + @Test + void TestLn() { + ScientificFeatures naturalLogTest = new ScientificFeatures(); + double naturalLogT = naturalLogTest.ln(5); + Assertions.assertEquals(1.6094379124341003, naturalLogT); + + } + + @Test + void TestInverseLn() { + ScientificFeatures inverseNaturalLogTest = new ScientificFeatures(); + double inverseNaturalLogT = inverseNaturalLogTest.inverseLn(5); + Assertions.assertEquals(148.41315910257657, inverseNaturalLogT); + } + + +} \ No newline at end of file