diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 00000000..06981ed5 Binary files /dev/null and b/.DS_Store differ diff --git a/ScientificCalculator.Maven b/ScientificCalculator.Maven new file mode 160000 index 00000000..8628a3ce --- /dev/null +++ b/ScientificCalculator.Maven @@ -0,0 +1 @@ +Subproject commit 8628a3ce18b94b2beac74fcccaa21c2fa2ab0f8d diff --git a/pom.xml b/pom.xml index e7cb4f6b..8e6f0fb5 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,21 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + + junit + junit + RELEASE + test + + - + + + junit + junit + 4.12 + test + + \ No newline at end of file diff --git a/src/.DS_Store b/src/.DS_Store new file mode 100644 index 00000000..78b6c8b2 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 00000000..e7e9d11d --- /dev/null +++ b/src/.idea/.gitignore @@ -0,0 +1,2 @@ +# Default ignored files +/workspace.xml diff --git a/src/.idea/misc.xml b/src/.idea/misc.xml new file mode 100644 index 00000000..aa66c766 --- /dev/null +++ b/src/.idea/misc.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/src/.idea/modules.xml b/src/.idea/modules.xml new file mode 100644 index 00000000..f669a0e5 --- /dev/null +++ b/src/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/src/.idea/vcs.xml b/src/.idea/vcs.xml new file mode 100644 index 00000000..6c0b8635 --- /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 00000000..a31746fe 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 00000000..38cf0818 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 00000000..382707c1 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 00000000..d6f72465 Binary files /dev/null and b/src/main/java/com/zipcodewilmington/.DS_Store differ 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..44db9581 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -0,0 +1,127 @@ +package com.zipcodewilmington.scientificcalculator; + +public class Calculator { + + public String mode = "dec"; + + + + public double add(double var1, double var2) { + return var1 + var2; + } + + public double subtract(double var1, double var2) { + return var1 - var2; + } + + public double multiply(double var1, double var2) { + return var1 * var2; + } + + public double divide(double var1, double var2) { + return var1 / var2; + } + + public double square(double var1) { + return var1 * var1; + } + + public double squareRoot(double var1) { + return Math.sqrt(var1); + } + + public double exponent(double var1, double var2) { + return Math.pow(var1, var2); + } + + public double inverse(double var1) { + return (1 / var1); + } + + public double signSwitch(double var1) { + return (var1 * -1); + } + + public double sin(double var1) { + return (Math.sin(var1)); + } + + public double cos(double var1) { + return (Math.cos(var1)); + } + + public double tangent(double var1) { + return (Math.tan(var1)); + + } + + public double InverseSin(double var1) { + return (Math.asin(var1)); + } + + public double InverseCos(double var1) { + return (Math.acos(var1)); + } + + public double InverseTangent(double var1) { + return (Math.atan(var1)); + } + + public double log(double var1) { + return (Math.log(var1)); + } + + public double log10X(double var1) { + return (Math.log10(var1)); + } + + public double invLog(double var1) { + return (Math.pow(10,var1)); + } + + public double invNatLog(double var1) { + return (Math.exp(var1)); + } + + + public double factorial(double var1) { + if (var1 < 0) {return (Double.NaN);} + else { + double factorial = 1; + + for (int i = 2; i <= var1; i++) { + factorial = factorial * i; + } + return factorial; + } + } + + public String DecimalToOther(int var1, int radix){ + return Integer.toString(var1, radix); + } + public double toRadians(double var1) { + return Math.toRadians(var1); + } + public double toDegrees(double var1) { + return Math.toDegrees(var1); + } + + public double secretof73 (double var1) { + var1 = ((((var1 * 10001) / 137) / var1)); + return var1; + } + public boolean isPrime(double n) { + if (n <= 1 || n != (int)n) { + return false; + } + + for (int i = 2; i < Math.sqrt(n); i++) { + if (n % i == 0) { + return false; + } + } + return true; + } + +} + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 83f0e97f..582f163b 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -17,7 +17,7 @@ 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; } @@ -27,6 +27,14 @@ public static Integer getIntegerInput(String prompt) { } public static Double getDoubleInput(String prompt) { - return null; + Scanner scanner = new Scanner(System.in); + print(prompt); + while(true){ + try { + return Double.valueOf(scanner.nextLine()); + } catch (Exception e) { + print("Input invalid, please enter again:"); + } + } } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f421325..1582e2dc 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,17 +1,236 @@ package com.zipcodewilmington.scientificcalculator; +import java.text.DecimalFormat; +import java.text.NumberFormat; + /** * 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); + + //Create a instance of Calculator + Calculator c = new Calculator(); + NumberFormat nf = new DecimalFormat("0.#####################"); + String result = ""; + double cur = 0.0; + double curTemp = 0.0; + double mem = 0; + int mode = 10; + + Console.println("=================================================="); + Console.println("!!!!Welcome to the Calculator Team 3!!!!"); + Console.println("=================================================="); + while(true) { + curTemp = cur; + if(mode != 10) { + Console.println("[ "+modeName(mode)+" Mode ] (Any decimal point will be truncated)"); + Console.println("Current Value: " + c.DecimalToOther((int)cur,mode)); + }else { + Console.println("Current Value: " + nf.format(cur)); + } + + String command = Console.getStringInput("Please enter a command! (Enter HELP for user manual) "); + + if (command.equalsIgnoreCase("add") || command.equalsIgnoreCase("sub") || + command.equalsIgnoreCase("mul") || command.equalsIgnoreCase("div") + || command.equalsIgnoreCase("pow") || command.equalsIgnoreCase("set")) { + + + double num1 = Console.getDoubleInput("Please enter a number: "); + + if (command.equalsIgnoreCase("add")) { + cur = c.add(cur, num1); + } else if (command.equalsIgnoreCase("sub")) { + cur = c.subtract(cur, num1); + } else if (command.equalsIgnoreCase("mul")) { + cur = c.multiply(cur, num1); + } else if (command.equalsIgnoreCase("div")) { + cur = c.divide(cur, num1); + } else if (command.equalsIgnoreCase("pow")) { + cur = c.exponent(cur, num1); + } else if(command.equalsIgnoreCase("set")) { + cur = num1; + //num1 = cur; + //ans = "Y"; + } + + }else if(command.equalsIgnoreCase("useM")) { + cur = mem; + }else if(command.equalsIgnoreCase("M+")) { + mem += cur; + Console.println("OK! I added "+ nf.format(cur) +" to memory! Memory is now "+nf.format(mem)); + }else if(command.equalsIgnoreCase("clearM")) { + mem = 0 ; + Console.println("OK! I reset the memory, memory is now "+nf.format(mem)); + }else if(command.equalsIgnoreCase("showM")) { + Console.println("M is "+nf.format(mem)); + }else if(command.equalsIgnoreCase("M")){ + mem = cur; + Console.println("OK! Memory is now set to "+nf.format(mem)); + }else if(command.equalsIgnoreCase("BYE")){ + break; + }else if(command.equalsIgnoreCase("zipcode")){ + Console.println("Cohort 6.0 is the BEST COHORT EVER!!!!!"); + }else{ + + if(command.equalsIgnoreCase("neg")) { + cur = c.signSwitch(cur); + }else if(command.equalsIgnoreCase("inv")) { + cur = c.inverse(cur) ; + }else if(command.equalsIgnoreCase("sq")) { + cur = c.square(cur) ; + }else if(command.equalsIgnoreCase("sqrt")){ + cur = c.squareRoot(cur) ; + }else if(command.equalsIgnoreCase("sin")){ + cur = c.sin(cur); + }else if(command.equalsIgnoreCase("cos")){ + cur = c.cos(cur); + }else if(command.equalsIgnoreCase("tan")){ + cur = c.tangent(cur); + }else if(command.equalsIgnoreCase("arcsin")){ + cur = c.InverseSin(cur); + }else if(command.equalsIgnoreCase("arccos")){ + cur = c.InverseCos(cur); + }else if(command.equalsIgnoreCase("arctan")){ + cur = c.InverseTangent(cur); + }else if(command.equalsIgnoreCase("ln")){ + cur = c.log(cur); + }else if(command.equalsIgnoreCase("log10")) { + cur = c.log10X(cur); + }else if(command.equalsIgnoreCase("invlog")) { + cur = c.invLog(cur); + }else if(command.equalsIgnoreCase("ex")) { + cur = c.invNatLog(cur); + }else if(command.equalsIgnoreCase("!")) { + cur = c.factorial(cur); + }else if(command.equalsIgnoreCase("toDeg")) { + cur = c.toDegrees(cur); + }else if(command.equalsIgnoreCase("toRad")) { + cur = c.toRadians(cur); + }else if(command.equalsIgnoreCase("toHex")) { + result = c.DecimalToOther((int)cur, 16); + }else if(command.equalsIgnoreCase("toOct")) { + result = c.DecimalToOther((int)cur, 8); + }else if(command.equalsIgnoreCase("toBin")) { + result = c.DecimalToOther((int)cur, 2); + }else if(command.equalsIgnoreCase("always73")) { + if(cur<1000){ + Console.println("Sorry, this only works if input is a 4-digit number!"); + } + }else if(command.equalsIgnoreCase("c")){ + cur = 0; + }else if(command.equalsIgnoreCase("isPrime")||command.equalsIgnoreCase("mode16")|| + command.equalsIgnoreCase("mode10")|| command.equalsIgnoreCase("mode8")|| + command.equalsIgnoreCase("mode2")||command.equalsIgnoreCase("mode2")) { + + }else{ + Console.println("That's not a valid command!!"); + } + } + + + + //print result + if(Double.isNaN(cur) || cur == Double.POSITIVE_INFINITY || cur == Double.NEGATIVE_INFINITY ) { + Console.println("ERROR!!! :("); + cur = curTemp; + }else if(command.equalsIgnoreCase("toHex")){ + Console.println("Decimal "+ (int)cur +" is " + result + " in Hexadecimal!"); + }else if(command.equalsIgnoreCase("toOct")){ + Console.println("Decimal "+ (int)cur +" is " + result + " in Octal!"); + }else if(command.equalsIgnoreCase("toBin")){ + Console.println("Decimal "+ (int)cur +" is " + result + " in Binary!"); + }else if(command.equalsIgnoreCase("always73")){ + double a = c.multiply(cur,10001); + double b = c.divide(a,137); + double cc = c.divide(b,cur); + + Console.println(cur + " * 10001 = " + a ); + Console.println(a+" / 137 = "+ b); + Console.println(b + " / "+cur+" = " + cc ); + cur = c.secretof73(cur); + Console.println("Your result is " + nf.format(cur) + " :)"); + + }else if(command.equalsIgnoreCase("isPrime")) { + if(c.isPrime(cur)) + Console.println((int)cur + " is a prime"); + else{ + Console.println(nf.format(cur) + " is not a prime"); + } + }else if(command.equalsIgnoreCase("mode10")){ + mode = 10; + Console.println("Ok! Switched to mode "+mode); + }else if(command.equalsIgnoreCase("mode16")){ + mode = 16; + Console.println("Ok! Switched to mode "+mode); + }else if(command.equalsIgnoreCase("mode8")){ + mode = 8; + Console.println("Ok! Switched to mode "+mode); + }else if(command.equalsIgnoreCase("mode2")){ + mode = 2; + Console.println("Ok! Switched to mode "+mode); + }else if (command.equalsIgnoreCase("help")) { + Console.print("Here are the available commends:\n" + + printHelp("Set Value", "set") + + printHelp("Clear Value", "c") + + printHelp("Add", "add") + + printHelp("Subtract", "sub") + + printHelp("Multiply", "mul") + + printHelp("Divide", "div") + + printHelp("Exponent", "pow") + + printHelp("Switch Sign", "neg") + + printHelp("Inverse", "inv") + + printHelp("Sine", "sin") + + printHelp("Cosine", "cos") + + printHelp("Tangent", "tan") + + printHelp("Inverse Sine", "arcsin") + + printHelp("Inverse Cosine", "arccon") + + printHelp("Inverse Tangent", "arctan") + + printHelp("Logarithm", "log10") + + printHelp("Inverse Log", "invlog") + + printHelp("Natural Log ", "ln") + + printHelp("Inverse Natural Log", "ex") + + printHelp("Inverse number", "inv") + + printHelp("Square", "sq") + + printHelp("Square Root", "sqrt") + + printHelp("Factorial", "!") + + printHelp("Degree to Radian", "toRad") + + printHelp("Radian to Degree", "toDeg") + + printHelp("Hexadecimal Mode", "mode16") + + printHelp("Decimal Mode", "mode10") + + printHelp("Octal Mode", "mode8") + + printHelp("Binary Mode", "mode2") + + printHelp("Set memory", "M") + + printHelp("Add value to memory", "M+") + + printHelp("Show value in memory", "showM")+ + printHelp("Use the value in memory", "useM")+ + printHelp("Clear memory", "clearM") + ); + }else{ + String d = ""; + if(mode != 10) { d = "decimal "; } + Console.println("Your "+d+"result is " + nf.format(cur) + " :)"); + } + + Console.println("=================================================="); + + } + } + + public static String printHelp(String description, String ops ){ + return String.format("%-27s%s\n", description, ops).replace(' ', '-'); + } + public static String modeName(int radix){ + if(radix == 10){ + return "Decimal"; + }else if(radix == 2){ + return "Binary"; + }else if(radix == 8){ + return "Octal"; + }else if(radix ==16){ + return "Hexadecimal"; + } + return "Not Possible"; } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Scientific Calculator.uml b/src/main/java/com/zipcodewilmington/scientificcalculator/Scientific Calculator.uml new file mode 100644 index 00000000..7998e554 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Scientific Calculator.uml @@ -0,0 +1,16 @@ + + + JAVA + + + + + + + + Methods + + All + private + + diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 94e8d987..9b9e9682 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,7 +1,242 @@ package com.zipcodewilmington.scientific_calculator; +import com.zipcodewilmington.scientificcalculator.Calculator; +import org.junit.Test; +import static org.junit.Assert.assertEquals; /** * Created by leon on 2/9/18. */ public class TestMainApplication { -} + @Test + public void test1() { + Calculator c1 = new Calculator(); + assertEquals(55.0, c1.add(10.0, 45.0), 0.01); + assertEquals(2.0, c1.add(-5.0, 7.0), 0.01); + assertEquals(-290.0, c1.add(-25.0, -265.0), 0.01); + assertEquals(100012345.0, c1.add(100000000, 12345.0), 0.01); + assertEquals(110.69, c1.add(23.567, 87.123), 0.01); + } + @Test + public void test2() { + Calculator c1 = new Calculator(); + assertEquals(-35.0, c1.subtract(10.0, 45.0), 0.01); + assertEquals(-12.0 ,c1.subtract(-5.0, 7.0), 0.01); + assertEquals(240.0 ,c1.subtract(-25.0, -265.0), 0.01); + assertEquals(-33.15 ,c1.subtract(34.678, 67.832), 0.01); + assertEquals(-63.556 ,c1.subtract(23.567, 87.123), 0.01); + } + @Test + public void test3() + { + Calculator c1 = new Calculator(); + assertEquals(50.0 ,c1.multiply(10.0, 5.0), 0.01); + assertEquals(-53.0 ,c1.multiply(-10.0, 5.3), 0.01); + assertEquals(45.27 ,c1.multiply(1.002, 45.180), 0.01); + assertEquals(203.205 ,c1.multiply(-34.50, -5.89), 0.01); + assertEquals(60.795 ,c1.multiply(0.579, 105.0), 0.01); + } + @Test + public void test4() + { + Calculator c1 = new Calculator(); + assertEquals(2.0, c1.divide(10.0, 5.0), 0.01); + assertEquals(3.114, c1.divide(106.0, 34.04), 0.01); + assertEquals(-31.267, c1.divide(-23.45, 0.75), 0.01); + assertEquals(3.0, c1.divide(0.75, 0.25), 0.01); + assertEquals(300.0, c1.divide(.09, 0.0003), 0.01); + } + @Test + public void test5() + { + Calculator c1 = new Calculator(); + assertEquals(25.0, c1.square( 5.0), 0.01); + assertEquals(1.0, c1.square( 1.0), 0.01); + assertEquals(25.0, c1.square( -5.0), 0.01); + assertEquals(0.1369, c1.square( 0.370), 0.01); + assertEquals(1000000.0, c1.square( 1000.0), 0.01); + } + @Test + public void test6() { + Calculator c1 = new Calculator(); + assertEquals(5.0, c1.squareRoot(25.0), 0.01); + assertEquals(Double.NaN, c1.squareRoot(-1.0), 0.01); + assertEquals(1.0, c1.squareRoot(1.0), 0.01); + assertEquals(12.0, c1.squareRoot(144.0), 0.01); + assertEquals(31.623, c1.squareRoot(1000.0), 0.01); + } + @Test + public void test7() { + Calculator c1 = new Calculator(); + assertEquals(32.0, c1.exponent(2.0, 5.0), 0.01); + assertEquals(0.03125, c1.exponent(2.0, -5.0), 0.01); + assertEquals(1.189, c1.exponent(2.0, 0.25), 0.01); + assertEquals(0.01, c1.exponent(10.0, -2.0), 0.01); + assertEquals(282475249.0, c1.exponent(7.0, 10.0), 0.01); + } + @Test + public void test8() { + Calculator c1 = new Calculator(); + assertEquals(0.01, c1.inverse(100.0), 0.01); + assertEquals(0.04, c1.inverse(25.0), 0.01); + assertEquals(2.0, c1.inverse(0.5), 0.01); + assertEquals(-0.0435, c1.inverse(-23.0), 0.01); + assertEquals(0.08734, c1.inverse(11.45), 0.01); + } + @Test + public void test9() { + Calculator c1 = new Calculator(); + assertEquals(-7.0, c1.signSwitch(7.0), 0.01); + assertEquals(7.0, c1.signSwitch(-7.0), 0.01); + assertEquals(-0.04, c1.signSwitch(0.04), 0.01); + assertEquals(4.67, c1.signSwitch(-4.67), 0.01); + assertEquals(67.89, c1.signSwitch(-67.89), 0.01); + } + @Test + public void test10() { + Calculator c1 = new Calculator(); + assertEquals(0.0, c1.sin(0.0), 0.01); + assertEquals(-0.468, c1.sin(500.0), 0.01); + assertEquals(-0.894, c1.sin(-90.0), 0.01); + assertEquals(0.102, c1.sin(75.5), 0.01); + assertEquals(-0.851, c1.sin(-310.0), 0.01); + } + + @Test + public void test11() { + Calculator c1 = new Calculator(); + assertEquals(0.154, c1.cos(30.0), 0.01); + assertEquals(1.0, c1.cos(0.0), 0.01); + assertEquals(0.814, c1.cos(-120.0), 0.01); + assertEquals(-0.884, c1.cos(500.0), 0.01); + assertEquals( -0.839, c1.cos(-10.0), 0.01); + } + + @Test + public void test12() { + Calculator c1 = new Calculator(); + assertEquals(0.0, c1.tangent(0.0), 0.01); + assertEquals( 0.713, c1.tangent(120.0), 0.01); + assertEquals(0.134, c1.tangent(-25.0), 0.01); + assertEquals(-0.074, c1.tangent( 65.9), 0.01); + assertEquals(-3.38, c1.tangent(360.0), 0.01); + + } + + @Test + public void test13() { + Calculator c1 = new Calculator(); + assertEquals(Double.NaN, c1.InverseSin(30.0), 0.01); + assertEquals(1.571, c1.InverseSin(1.0), 0.01); + assertEquals(0.644, c1.InverseSin(0.6), 0.01); + assertEquals(-0.253, c1.InverseSin(-0.25), 0.01); + assertEquals(0.0, c1.InverseSin(0.0), 0.01); + } + @Test + public void test14() { + Calculator c1 = new Calculator(); + assertEquals(Double.NaN, c1.InverseCos(30.0), 0.01); + assertEquals(2.587, c1.InverseCos(-0.85), 0.01); + assertEquals(0.00, c1.InverseCos(1.0), 0.01); + assertEquals(1.17, c1.InverseCos(0.39), 0.01); + assertEquals(2.214, c1.InverseCos(-0.60), 0.01); + } + @Test + public void test15() { + Calculator c1 = new Calculator(); + assertEquals(1.537, c1.InverseTangent(30.0), 0.01); + assertEquals(0.785, c1.InverseTangent(1.0), 0.01); + assertEquals(1.554, c1.InverseTangent(60.0), 0.01); + assertEquals(1.559, c1.InverseTangent(90.0), 0.01); + assertEquals(-1.559, c1.InverseTangent(-84.0), 0.01); + } + @Test + public void test16() { + Calculator c1 = new Calculator(); + assertEquals(4.499, c1.log(90.0), 0.01); + assertEquals(0.0, c1.log(1.0), 0.01); + assertEquals(Double.NaN, c1.log(-60.0), 0.01); + assertEquals(3.912, c1.log(50.0), 0.01); + assertEquals(9.210, c1.log(10000.0), 0.01); + } + @Test + public void test17() { + Calculator c1 = new Calculator(); + assertEquals(1.954, c1.log10X(90.0), 0.01); + assertEquals(0.0, c1.log10X(1.0), 0.01); + assertEquals(Double.NaN, c1.log10X(-60.0), 0.01); + assertEquals(1.699, c1.log10X(50.0), 0.01); + assertEquals(4.0, c1.log10X(10000.0), 0.01); + } + @Test + public void test18() { + Calculator c1 = new Calculator(); + assertEquals(100.00, c1.invLog(2.0), 0.01); + assertEquals(1.0E25, c1.invLog(25.0), 0.01); + assertEquals(1.778, c1.invLog(0.25), 0.01); + assertEquals(0.00001, c1.invLog(-5.0), 0.01); + assertEquals(1.002, c1.invLog(0.001), 0.01); + } + @Test + public void test19() { + Calculator c1 = new Calculator(); + assertEquals(148.41, c1.invNatLog(5.0), 0.01); + assertEquals(2.718, c1.invNatLog(1.0), 0.01); + assertEquals(0.0067, c1.invNatLog(-5.0), 0.01); + assertEquals(1.994, c1.invNatLog(0.69), 0.01); + assertEquals(22026.466, c1.invNatLog(10.0), 0.01); + } + @Test + public void test20() { + Calculator c1 = new Calculator(); + assertEquals(720.0, c1.factorial(6.0), 0.01); + assertEquals(Double.NaN, c1.factorial(-1.0), 0.01); + assertEquals(1.0, c1.factorial(1.0), 0.01); + assertEquals(1.5511210043330986E25, c1.factorial( 25), 0.01); + assertEquals(1.0, c1.factorial(0), 0.01); + } + @Test + public void test21() { + Calculator c1 = new Calculator(); + assertEquals("ff", c1.DecimalToOther(255, 16)); + assertEquals("1f4", c1.DecimalToOther(500, 16)); + assertEquals("1", c1.DecimalToOther(1, 16)); + assertEquals("-5a", c1.DecimalToOther(-90, 16)); + assertEquals("19", c1.DecimalToOther(25, 16)); + } + @Test + public void test22() { + Calculator c1 = new Calculator(); + assertEquals("10", c1.DecimalToOther(2, 2)); + assertEquals("1111100", c1.DecimalToOther(124, 2)); + assertEquals("0", c1.DecimalToOther(0, 2)); + assertEquals("10000000001", c1.DecimalToOther(1025, 2)); + assertEquals("1010011101", c1.DecimalToOther(669, 2)); + } + @Test + public void test23() { + Calculator c1 = new Calculator(); + assertEquals(3.14, c1.toRadians(180), 0.01); + assertEquals(4.451, c1.toRadians(255), 0.01); + assertEquals(0.261, c1.toRadians(15), 0.01); + assertEquals(-1.571, c1.toRadians(-90), 0.01); + assertEquals(0, c1.toRadians(0), 0.01); + } + @Test + public void test24() { + Calculator c1 = new Calculator(); + assertEquals(180.00, c1.toDegrees(Math.PI), 0.001); + assertEquals(515.662, c1.toDegrees(9), 0.001); + assertEquals(0.00, c1.toDegrees(0), 0.001); + assertEquals(572.958, c1.toDegrees(10), 0.001); + assertEquals(20626.480624, c1.toDegrees(360), 0.001); + } + @Test + public void test25() { + Calculator c1 = new Calculator(); + assertEquals(73.00, c1.secretof73(8419), 0.001); + assertEquals(73.00, c1.secretof73(52), 0.001); + assertEquals(73.00, c1.secretof73(1492), 0.001); + assertEquals(73.00, c1.secretof73(813), 0.001); + assertEquals(73.00, c1.secretof73(2468), 0.001); + } +} \ No newline at end of file