From 0602287c1005e5391a164ab1b52c676fa68aa106 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Sat, 27 Feb 2021 16:09:02 -0500 Subject: [PATCH 01/15] Created/Tested switchDisplayMode + switchUnitsMode (#1) Co-authored-by: xiong --- .DS_Store | Bin 0 -> 6148 bytes pom.xml | 20 +++++ src/.DS_Store | Bin 0 -> 6148 bytes src/main/.DS_Store | Bin 0 -> 6148 bytes src/main/java/.DS_Store | Bin 0 -> 6148 bytes src/main/java/com/.DS_Store | Bin 0 -> 6148 bytes src/main/java/com/zipcodewilmington/.DS_Store | Bin 0 -> 6148 bytes .../scientificcalculator/MainApplication.java | 75 ++++++++++++++++++ .../scientificcalculator/NewCalculator.java | 27 +++++++ src/test/.DS_Store | Bin 0 -> 6148 bytes src/test/java/.DS_Store | Bin 0 -> 6148 bytes src/test/java/com/.DS_Store | Bin 0 -> 6148 bytes src/test/java/com/zipcodewilmington/.DS_Store | Bin 0 -> 6148 bytes .../TestMainApplication.java | 46 +++++++++++ 14 files changed, 168 insertions(+) create mode 100644 .DS_Store create mode 100644 src/.DS_Store create mode 100644 src/main/.DS_Store create mode 100644 src/main/java/.DS_Store create mode 100644 src/main/java/com/.DS_Store create mode 100644 src/main/java/com/zipcodewilmington/.DS_Store create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java create mode 100644 src/test/.DS_Store create mode 100644 src/test/java/.DS_Store create mode 100644 src/test/java/com/.DS_Store create mode 100644 src/test/java/com/zipcodewilmington/.DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..6825f185360cf00ca3df4055d3183f646f55291e GIT binary patch literal 6148 zcmeHKO>Pr06n<_(;{+kHKx)}}gTx}L5(*RvAq^p2bb*8z1PegvOeVA=O~=v9ga9FE zHXNe8L66cCa1agvpMP4Kq}?J!{iNsb+3&~lm)IT?5$lel4pEbcI8OX7 zX`7x>kDdcJkQbR9f0l8)ka3%G8c<9_N~r*TfDWh+4Jbi7MjOB*DMP*Z&lz%Bk$qpN zSV6^%2J`c>wTq*|Nj?e_UF#$qC2?M~+dtS!rFw0(#(9G`ZZzKe`*PwJK{3v|LH1Vl zUIfK{Xzf>0CTDgKzK(~Je)HBdnHE8u4l|t`M?-|XdlRRToOIV8BGWyLsOVJ?8GxKU&|NGL^b`K`KP9?Ot}X-i&&97_T?*XF9RrSmOBhh+gMcdZ zES3iK(Sb%k0f1EuYk{pk8dQ$3=vgcc!UJI@6=+hKePS?^j&Wh*Jd344lTOS&KA4@E z*%u1av!lMy;lw-UB&BAE$|6t06mMPL5x7$hk&NRHI9M5%D`_Vqm(fK literal 0 HcmV?d00001 diff --git a/pom.xml b/pom.xml index e7cb4f6b..4cf506b5 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,26 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + + junit + junit + 4.12 + test + + + junit + junit + 4.12 + 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 0000000000000000000000000000000000000000..0700b8a8626336a8a6ff9ad36f72aa4d172d617b GIT binary patch literal 6148 zcmeHK!A{#i5S;~=Zc+@$F9gkC%Yo`L_H0p7a-olrs<6$|@!3%(b>tk^}&;?i+>D*OB@JU6Hv(sJ-<<+0XH-F({o93Pu;TqV`0>?Ol}?tMtA<5cXA#^f_QNk3(S@nP%vJ5y9i zRt$zVIqMG)abeKYQvQPD5$Jh5|V-O!E0*4kvU(S6+xUv}P3+u>w$v(pY=ZM>OI z8+vuUyS;mK^6h-`efs0VeFueu%E~jr-*5?Iw!pJ^SmdVoiZPB4sGzid|G&o`{zLsgpX7U<0nfmLVn78u@lFp*lDqZR;`pu&p+`^_j;kHo6f|-j gTZ6CSHK-N%LNS5Z-O8ZYyFBf<5LUc<7C!P{dRghHnJtQNKvac+!9z*Qkf` z$`7Rv&$uAT|7QUAF2in^$A--Nw14|BxA~?-6*7zSNByqZ=NG>l2K~5HdgZBfW?^wj zh@8l+dh6Qnbd^YN=>#S9T|ptXSVDAJm(-clYCm z$>WpW3l1Nul2wCKcm`uu;LzS5Z-O8ZYyFBf<5LUc<7<^A4CYX9(ofZdQho}EgFbfX;X{VN?t?X$S3e| zbY^#2DAk(?mKm7+CbKge=G(BF5kkmXuT>SID1=a;h?zVL-w4j5PDzG5SwM+v=<6WT z0X*SyEdPN4+`Fu}7FygjqKW<6hne+HBc>3F3i{o9+U57)J_@@@rSc&&+1%Xxf>H%l zSSnn4x4Q2oe$wmK{LVQ(9s9{`K=z5&(b)Eb)3Dud7FP~+ocLkf?wI7T)rOFZvoLPy zeogn{R@bcK*$JicD&H)Y27}G&cG=me>fW03`5%2$_pZk9k!~-+H49q42GFSKNHK>j5 z)~PD-u601KKv6I*wKz@z!(7D>i&t?8)Cl+;Gyq+~)FOC5_(#CdzymYzrwn`nPqA47 literal 0 HcmV?d00001 diff --git a/src/main/java/com/.DS_Store b/src/main/java/com/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..8497804a65728d7152a86d76c635affcb25fe549 GIT binary patch literal 6148 zcmeHKQEL-H5S~q=ZX#lYf_>Z7%kW|sZ#*u5blHJWEbq8<@xC}XRG;Sa*|tZUK=o(-UK zH7sQ`rkZjp)}qC69U0(vcaP5T#wK(`zrMdy_)0pa3f^+Rut#ZOQ$+Kp@(lX$hZ9(r zs*u*RNvQBGofP@38VtUx)<*lr&0AV`b@xv9LwsWExJs(|Y?Msj@zblMI!S~5+S=m6 zPSQ8|xIXA@zOZGLcoCR>yGXm^tKj@?ctNYc{JEv z_RV5vXV5o~x1TPT9ew}7@cI7X>Dl?>)AI8dw>eVyxSiY$xPq@RE=JVx}Y z(yD@>Fdz&F16RU8IE?h|D_LC@6$XTX>&yV34+hE@1#CRJqXUC$0f23|oxtWFM9wh* zqkxS^%s`Y+1^QGKS`6jW;Wr^J3fOq`>7+vQp~A{4bSTQLj{3%hlZrgbC=3V#zcawS zAEd|k|I5Gk|1L-dVL%x8KN(Q%y?Aegy@k7VZI^u48t5UEh2t8J7b!5@Rg74^inpLn Z;5TdlqkxS^cp&m4;AoIR82G0Q`~)7AYZL$g literal 0 HcmV?d00001 diff --git a/src/main/java/com/zipcodewilmington/.DS_Store b/src/main/java/com/zipcodewilmington/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5eb533958372cd0c3fb0b3c7382f470c4eb132a7 GIT binary patch literal 6148 zcmeHKQEL-H5S~q=ZX#kH3ifed3Vp~!V$}*F9I-z1O}NrNsI+%UvW%LF*T!|LP-^c*(-6oaTuZ+fYegB4(P!9hTV}gCPG&#uaFwJd>9R6UQKzF`5 zf%OM<(ph;P>U>Gh^Q^3Ty|1dV(Y$f}+7C#i(?3Vn3mEOSeusTl4vD|6$kM z?>%00&3tdK*EJ7zA1xLweQ&$}^x*W}<@@=E#m7(X6-nVkcXBu25=u$C+#3Du=ePV4h*gZ05;)v0-Jvg zImZNy0@fZe15rK|=u=f_F_ce---Ng*VC~VTlM2m;3M;G7p(wXH>KhkMD)K0!Fdz*4 z$N=|#kPhGf&wt(jyC4~a0b$_(WI#3d)WLjs_WofweO59f*H!RR910 literal 0 HcmV?d00001 diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f421325..1ca04c68 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -4,6 +4,9 @@ * Created by leon on 2/9/18. */ public class MainApplication { + private String currentMode = "binary"; + private String currentUnit = "degrees"; + public static void main(String[] args) { Console.println("Welcome to my calculator!"); String s = Console.getStringInput("Enter a string"); @@ -13,5 +16,77 @@ public static void main(String[] args) { 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); + + + + } + //DISPLAY CHANGES + + public void getMode() { + System.out.println(currentMode); + } + //public void setMode(String newMode){currentMode = newMode;} + + public String switchDisplayMode(){ + if (currentMode.equals("binary")) { + currentMode = "octal"; + System.out.println("octal"); + } else if (currentMode.equals("octal")) { + currentMode = "decimal"; + System.out.println("decimal"); + } else if (currentMode.equals("decimal")) { + currentMode = "hexadecimal"; + System.out.println("hexadecimal"); + } else if (currentMode.equals("hexadecimal")) { + currentMode = "binary"; + System.out.println("binary"); + } else System.out.println("Err"); + + return currentMode; + } + + public String switchDisplayMode(String mode) { + if (mode.equals("binary")) { + currentMode = "binary"; + } else if (mode.equals("octal")) { + currentMode = "octal"; + } else if (mode.equals("decimal")) { + currentMode = "decimal"; + } else if (mode.equals("hexadecimal")) { + currentMode = "hexadecimal"; + } else mode = "Err"; + System.out.println(mode); + return mode; } + + //UNIT CHANGES + + public void getUnit() { + System.out.println(currentUnit); + } + + public String switchUnitsMode(){ + if (currentUnit.equals("degrees")) { + currentUnit = "radians"; + System.out.println("radians"); + } else if (currentUnit.equals("radians")) { + currentUnit = "degrees"; + System.out.println("degrees"); + } else System.out.println("Err"); + + return currentUnit; + } + + public String switchUnitsMode(String mode) { + if (mode.equals("degrees")) { + currentUnit = "degrees"; + } else if (mode.equals("radians")) { + currentUnit = "radians"; + } else mode = "Err"; + System.out.println(mode); + return mode; + } + + + } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java new file mode 100644 index 00000000..e7c41c40 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java @@ -0,0 +1,27 @@ +package com.zipcodewilmington.scientificcalculator; + +public class NewCalculator { + static MainApplication calculator = new MainApplication(); + + public static void main(String[] args) { + calculator.switchDisplayMode(); + calculator.switchDisplayMode(); + calculator.switchDisplayMode(); + calculator.switchDisplayMode("Hellow"); + calculator.switchDisplayMode("binary"); + calculator.switchDisplayMode(); + + calculator.getMode(); + + calculator.switchUnitsMode(); + calculator.switchUnitsMode("degrees"); + calculator.switchUnitsMode(); + calculator.switchUnitsMode(); + calculator.switchUnitsMode("radians"); + calculator.switchUnitsMode("Break me"); + calculator.switchUnitsMode(); + calculator.switchUnitsMode(); + + } + +} diff --git a/src/test/.DS_Store b/src/test/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..4da071c09a636a352e5e6c9061d39c36b41a5976 GIT binary patch literal 6148 zcmeHK%}T>S5Z-O8ZYyFBf<5LUc<7C!P{dRghHnJtQNKvac+!9z*Qkf` z$`7Rv&$uAT|7QUAF2in^$A--Nw14|BxA~?-6*7zSNByqZ=NG>l2K~5HdgZBfW?^wj zh@8l+dh6Qnbd^YN=>#S9T|ptXSVDAJm(-clYCm z$>WpW3l1Nul2wCKcm`uu;LzS5Z-O8ZYyFBf<5LUc<7<^A4CYX9(ofZdQho}EgFbfX;X{VN?t?X$S3e| zbY^#2DAk(?mKm7+CbKge=G(BF5kkmXuT>SID1=a;h?zVL-w4j5PDzG5SwM+v=<6WT z0X*SyEdPN4+`Fu}7FygjqKW<6hne+HBc>3F3i{o9+U57)J_@@@rSc&&+1%Xxf>H%l zSSnn4x4Q2oe$wmK{LVQ(9s9{`K=z5&(b)Eb)3Dud7FP~+ocLkf?wI7T)rOFZvoLPy zeogn{R@bcK*$JicD&H)Y27}G&cG=me>fW03`5%2$_pZk9k!~-+H49q42GFSKNHK>j5 z)~PD-u601KKv6I*wKz@z!(7D>i&t?8)Cl+;Gyq+~)FOC5_(#CdzymYzrwn`nPqA47 literal 0 HcmV?d00001 diff --git a/src/test/java/com/.DS_Store b/src/test/java/com/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..8497804a65728d7152a86d76c635affcb25fe549 GIT binary patch literal 6148 zcmeHKQEL-H5S~q=ZX#lYf_>Z7%kW|sZ#*u5blHJWEbq8<@xC}XRG;Sa*|tZUK=o(-UK zH7sQ`rkZjp)}qC69U0(vcaP5T#wK(`zrMdy_)0pa3f^+Rut#ZOQ$+Kp@(lX$hZ9(r zs*u*RNvQBGofP@38VtUx)<*lr&0AV`b@xv9LwsWExJs(|Y?Msj@zblMI!S~5+S=m6 zPSQ8|xIXA@zOZGLcoCR>yGXm^tKj@?ctNYc{JEv z_RV5vXV5o~x1TPT9ew}7@cI7X>Dl?>)AI8dw>eVyxSiY$xPq@RE=JVx}Y z(yD@>Fdz&F16RU8IE?h|D_LC@6$XTX>&yV34+hE@1#CRJqXUC$0f23|oxtWFM9wh* zqkxS^%s`Y+1^QGKS`6jW;Wr^J3fOq`>7+vQp~A{4bSTQLj{3%hlZrgbC=3V#zcawS zAEd|k|I5Gk|1L-dVL%x8KN(Q%y?Aegy@k7VZI^u48t5UEh2t8J7b!5@Rg74^inpLn Z;5TdlqkxS^cp&m4;AoIR82G0Q`~)7AYZL$g literal 0 HcmV?d00001 diff --git a/src/test/java/com/zipcodewilmington/.DS_Store b/src/test/java/com/zipcodewilmington/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..9ed551852148b40e3342f4fb3de9edb199e93377 GIT binary patch literal 6148 zcmeHK!EVz)5S>i}Y=RIufaq~Al{n;(P@t6%k`>CKHzZf(&{nD41Zv56tJooe5ai#0 zKjI7c9C)+4sagdNJrn_&k!Id_c4k(7Ywdc8NDZc=K2e8=G?cN?g87B;IO~cuLSzl7 zT#te(%IFRBWF=bye27HPwWS@Zt2#rvp%11_Mddk zqu%zSYvx;9y{>t@`E;>p=?5GA=ex)6K75>iT73TEUXm0(b|-fOF5xSjE0Fmg0Y`%vVc?H4@DnT!Z*>3w literal 0 HcmV?d00001 diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 94e8d987..c5f7de10 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,7 +1,53 @@ package com.zipcodewilmington.scientific_calculator; +import static org.junit.Assert.assertEquals; +import com.zipcodewilmington.scientificcalculator.MainApplication; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; /** * Created by leon on 2/9/18. */ public class TestMainApplication { + + @Test + public void displayTest() { + MainApplication displaytester = new MainApplication(); + + assertEquals("octal", displaytester.switchDisplayMode()); + assertEquals("decimal", displaytester.switchDisplayMode()); + assertEquals("hexadecimal", displaytester.switchDisplayMode()); + } + + @Test + public void modeChange() { + MainApplication modeChanger = new MainApplication(); + + assertEquals("binary", modeChanger.switchDisplayMode("binary")); + assertEquals("hexadecimal", modeChanger.switchDisplayMode("hexadecimal")); + assertEquals("Err", modeChanger.switchDisplayMode("hello!")); + } + + @Test + public void unitChangeButton() { + MainApplication unitChanger = new MainApplication(); + + assertEquals("radians", unitChanger.switchUnitsMode()); + assertEquals("degrees", unitChanger.switchUnitsMode()); + assertEquals("radians", unitChanger.switchUnitsMode()); + } + + @Test + public void unitChange() { + MainApplication unitChanger1 = new MainApplication(); + + assertEquals("radians", unitChanger1.switchUnitsMode("radians")); + assertEquals("Err", unitChanger1.switchUnitsMode("Break me")); + assertEquals("degrees", unitChanger1.switchUnitsMode("degrees")); + } + + + + + } From f74aad35376c5745c81f8e70df2be25776109d85 Mon Sep 17 00:00:00 2001 From: jorget93 <78943159+jorget93@users.noreply.github.com> Date: Sat, 27 Feb 2021 19:08:22 -0500 Subject: [PATCH 02/15] Jorge branch (#2) Added/tested logarithm methods Co-authored-by: Jorge Co-authored-by: xyuan04 <78838190+xyuan04@users.noreply.github.com> --- pom.xml | 29 +++++++++++++++ .../scientificcalculator/MainApplication.java | 25 ++++++++++++- .../TestMainApplication.java | 36 ++++++++++++++++++- 3 files changed, 88 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 4cf506b5..278cdf18 100644 --- a/pom.xml +++ b/pom.xml @@ -29,4 +29,33 @@ + + + + + junit + junit + 4.12 + test + + + junit + junit + 4.12 + test + + + junit + junit + 4.12 + test + + + junit + junit + 4.12 + test + + + \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 1ca04c68..c3bff0d6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,5 +1,4 @@ package com.zipcodewilmington.scientificcalculator; - /** * Created by leon on 2/9/18. */ @@ -7,6 +6,7 @@ public class MainApplication { private String currentMode = "binary"; private String currentUnit = "degrees"; + public static void main(String[] args) { Console.println("Welcome to my calculator!"); String s = Console.getStringInput("Enter a string"); @@ -18,8 +18,31 @@ public static void main(String[] args) { Console.println("The user input %s as a d", d); + } + //Takes a value for num2 for the log equation. num1 is not used in this case + public static double logarithm(double num1) { + double newNum = Math.log10(num1); + System.out.println(newNum); + return newNum; + } + public double invLog(double num1) { + double newNum = Math.pow(10,num1); + System.out.println(newNum); + return newNum; } + public double natLog(double num1) { + double newNum = Math.log(num1); + System.out.println(newNum); + return newNum; + } + public double invNatLog(double num1) { + double newNum = Math.pow(Math.E,num1); + System.out.println(newNum); + return newNum; + } + + //DISPLAY CHANGES public void getMode() { diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index c5f7de10..25cfff16 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,15 +1,48 @@ package com.zipcodewilmington.scientific_calculator; import static org.junit.Assert.assertEquals; - import com.zipcodewilmington.scientificcalculator.MainApplication; +import org.junit.Test; +import static org.junit.Assert.*; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; + /** * Created by leon on 2/9/18. */ + public class TestMainApplication { + + @Test //Log base 10 method test + public void getLog10() { + MainApplication newLog = new MainApplication(); + assertEquals(1.0, newLog.logarithm(10.0), 0.0000001); + } + @Test //Log base 10 method Err test + public void getLog101() { + MainApplication newLog = new MainApplication(); + assertEquals(Double. NEGATIVE_INFINITY, newLog.logarithm(0.0), 0.0000001); + } + + + @Test //Inverted log test + public void getInvLog10() { + MainApplication newLog = new MainApplication(); + assertEquals(100000.0, newLog.invLog(5.0), 0.0000001); + } + @Test //Natural Log test + public void getNetLog() { + MainApplication newLog = new MainApplication(); + assertEquals(1.609437912, newLog.natLog(5.0), 0.0000001); + } + @Test //Inverted Natural Log test + public void getInvNetLog() { + MainApplication newLog = new MainApplication(); + assertEquals(148.4131591, newLog.invNatLog(5.0), 0.0000001); + } + + @Test public void displayTest() { MainApplication displaytester = new MainApplication(); @@ -50,4 +83,5 @@ public void unitChange() { + } From 8b79455e7bcf13c17fb526a587ae18032b78c238 Mon Sep 17 00:00:00 2001 From: jorget93 <78943159+jorget93@users.noreply.github.com> Date: Sat, 27 Feb 2021 21:38:05 -0500 Subject: [PATCH 03/15] Jorge branch (#4) Added more test fields. --- src/.DS_Store | Bin 6148 -> 6148 bytes src/main/.DS_Store | Bin 6148 -> 6148 bytes src/main/java/.DS_Store | Bin 6148 -> 6148 bytes src/main/java/com/.DS_Store | Bin 6148 -> 6148 bytes .../scientificcalculator/MainApplication.java | 21 ++++++++ .../TestMainApplication.java | 48 ++++++++++++++++++ 6 files changed, 69 insertions(+) diff --git a/src/.DS_Store b/src/.DS_Store index 0700b8a8626336a8a6ff9ad36f72aa4d172d617b..0787fb7b15229e3b1308635a538cf207523385ad 100644 GIT binary patch delta 112 zcmZoMXfc=|#>AjHu~68Ok%57Mg&~(Aks*^IuPnGIFDE}Q9ViA8X98jn0I`8sfB{*4 tvml2U%Vq_RUgpj09Q+(W+@$F9gkC%Yo`L_H0p7a-olrs<6$|@!3%(b>tk^}&;?i+>D*OB@JU6Hv(sJ-<<+0XH-F({o93Pu;TqV`0>?Ol}?tMtA<5cXA#^f_QNk3(S@nP%vJ5y9i zRt$zVIqMG)abeKYQvQPD5$Jh5|V-O!E0*4kvU(S6+xUv}P3+u>w$v(pY=ZM>OI z8+vuUyS;mK^6h-`efs0VeFueu%E~jr-*5?Iw!pJ^SmdVoiZPB4sGzid|G&o`{zLsgpX7U<0nfmLVn78u@lFp*lDqZR;`pu&p+`^_j;kHo6f|-j gTZ6CSHK-N%LNAjHu~1l-k%57Mg&~U}k)ezsu`IYKFDE}Q9ViA8X98jn0I`8sfMK&D t^D~ys4$LQ+HnVf^a{!IlY{>kbc{0CK8 delta 366 zcmZoMXfc=|#>B)qu~3YagMop8V`8C*EEA9c0?a_n$iN`L;F*)3oRpKF1mp{BEL_f5 z50YVF$YMxjC}T)OmIaDi1F^<`FaWZU)FqV{7eGxpnN*OISzKaZaGjBfnT3^&or8mm zgNv6dHaH`{Jh&vWq_o&6u_zkE3rH-r7fQWN`UP)qR zUTP6ocV|8pkRmu2L~qyXS{$!b+xgfsg8n?fkmy3LbbWM zfsTTSu~}^`Cx^JIp{-{^Ze>+Nywupby0f#CoK{2-DC!UmJGChACUOux=D*+7J4 iGdBk}2QV}@7Jg@*%rBzI3JOVu$%Z1*n*&6)FarP~bzNEj diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store index e8ff6d8f3a2a099183d6c78064b95472370076a1..0a8bc21eef2735eaef7786d6a2b9eb2fa2ef83ae 100644 GIT binary patch delta 82 zcmZoMXfc=|#>AjHu~3+iak3z@v>+1$1TX?AAQoWQEX(|gWwQhGQKrr89Q+(W#hVS8 azcWwf7g6K{DM|pTpKQXTyg5c>1v3CggbtVh delta 360 zcmZoMXfc=|#>B)qu~3YagMop8V`8C*G!u{k0?a_n$iN`Lke{5Clb;0S32ZD}$yg5( zXJ$xd$Y;p)%t6QjMXiBY<3AVxS#VWJ<;4Y16HX=-CJzu~2NHo+2aT!~knX#>sw6YMb+!XRvIZz`U1fGdl-A2T;l8M&|F# allet-IT;xk7!Ck2!(CG`BOPB%8cM^R7 delta 325 zcmZoMXfc=|#>B)qu~2NHo+2aj!~pA!7aACWj2<-^&z$_^q@4UD1_lNJAhrf#jsIZ4 zzyOr5Pbx1ifXbgtD#*z!E-^5;&d9{f!pg?Z!NJAB#mf~NoRME1T#{H)TI`fq6b<49 zB$i|(LD?bs`8jZQVp3RUYI(eXh;x2kNn&PRY7tm-W=bkhNlbWVUP^wsQ+{b)N-@}+ z;4p{`2L~qyXS{$!b+xgfsg8n?fkmy3LbbWMfsTTSu~}^`Cx^JIp{-{^Ze>+Nyw zpf7-ckr6^O@Iz@BHEUzfK9VA*)^JM(0I5nU0GEJ#NKga&Kg93rxTd13<# E0N>qNX8-^I diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index c3bff0d6..9f6c145f 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -20,22 +20,42 @@ public static void main(String[] args) { } + + //Following methods take a value (num1) for the log equations. + //Logarithms + //Takes a value for num2 for the log equation. num1 is not used in this case + public static double logarithm(double num1) { double newNum = Math.log10(num1); System.out.println(newNum); return newNum; } + + //Inverted Logs + + public double invLog(double num1) { double newNum = Math.pow(10,num1); System.out.println(newNum); return newNum; + + } + //Natural Logs + public double natLog(double num1) { + double newNum = Math.log(num1); + System.out.println(newNum); + return newNum; + } + //Inverted Natural Logs + } public double natLog(double num1) { double newNum = Math.log(num1); System.out.println(newNum); return newNum; } + public double invNatLog(double num1) { double newNum = Math.pow(Math.E,num1); System.out.println(newNum); @@ -112,4 +132,5 @@ public String switchUnitsMode(String mode) { + } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 25cfff16..473437d9 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,4 +1,7 @@ package com.zipcodewilmington.scientific_calculator; +import com.zipcodewilmington.scientificcalculator.MainApplication; +import org.junit.Test; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals; import com.zipcodewilmington.scientificcalculator.MainApplication; import org.junit.Test; @@ -7,6 +10,7 @@ import org.junit.BeforeClass; import org.junit.Test; + /** * Created by leon on 2/9/18. */ @@ -14,6 +18,50 @@ public class TestMainApplication { + //Log base 10 method tests + @Test + public void getLog0() { + MainApplication newLog = new MainApplication(); + assertEquals(3.0, newLog.logarithm(1000.0), 0.0000001); + assertEquals(1.0, newLog.logarithm(10.0), 0.0000001); + assertEquals(-0.3010299957, newLog.logarithm(0.5), 0.0000001); + assertEquals(-1.0, newLog.logarithm(0.1), 0.0000001); + assertEquals(Double. NEGATIVE_INFINITY, newLog.logarithm(0.0), 0.0000001); + assertEquals(Double.NaN, newLog.logarithm(-1.0), 0.0000001); + } + + + @Test //Inverted log base 10 test + public void getInvLog0() { + MainApplication newLog = new MainApplication(); + assertEquals(100000.0, newLog.invLog(5.0), 0.0000001); + assertEquals(10.0, newLog.invLog(1.0), 0.0000001); + assertEquals(3.16227766, newLog.invLog(0.5), 0.0000001); + assertEquals(1.258925412, newLog.invLog(0.1), 0.0000001); + assertEquals(0.1, newLog.invLog(-1.0), 0.0000001); + } + + + @Test //Natural Log tests + public void getNatLog0() { + MainApplication newLog = new MainApplication(); + assertEquals(1.609437912, newLog.natLog(5.0), 0.0000001); + assertEquals(0.0, newLog.natLog(1.0), 0.0000001); + assertEquals(Double.NEGATIVE_INFINITY, newLog.natLog(0.0), 0.0000001); + assertEquals(Double.NaN, newLog.natLog(-1), 0.0000001); + assertEquals(-2.302585093, newLog.natLog(0.1), 0.0000001); + } + + @Test //Inverted Natural Log tests + public void getInvNatLog0() { + MainApplication newLog = new MainApplication(); + assertEquals(148.4131591, newLog.invNatLog(5.0), 0.0000001); + assertEquals(1.0, newLog.invNatLog(0.0), 0.0000001); + assertEquals(0.3678794412, newLog.invNatLog(-1.0), 0.0000001); + assertEquals(1.105170918, newLog.invNatLog(0.1), 0.0000001); + assertEquals(0.904837418, newLog.invNatLog(-0.1), 0.0000001); + + @Test //Log base 10 method test public void getLog10() { MainApplication newLog = new MainApplication(); From 535948ff6d390c60b789f2b6e58ae015a162c846 Mon Sep 17 00:00:00 2001 From: theresa-mashura <78986299+theresa-mashura@users.noreply.github.com> Date: Sat, 27 Feb 2021 21:44:50 -0500 Subject: [PATCH 04/15] Theresa (#5) added factorial & memory Co-authored-by: Theresa Co-authored-by: xyuan04 <78838190+xyuan04@users.noreply.github.com> --- .../scientificcalculator/Console.java | 15 +- .../scientificcalculator/MainApplication.java | 159 ++++++++++++++++-- .../TestMainApplication.java | 37 +++- 3 files changed, 195 insertions(+), 16 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 83f0e97f..724f24c1 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -22,11 +22,20 @@ public static String getStringInput(String prompt) { return userInput; } + public static Integer getIntegerInput(String prompt) { - return null; + Scanner scanner = new Scanner(System.in); + println(prompt); + int userInput = scanner.nextInt(); + return userInput; } public static Double getDoubleInput(String prompt) { - return null; + Scanner scanner = new Scanner(System.in); + println(prompt); + double userInput = scanner.nextDouble(); + return userInput; } -} + + +} \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 9f6c145f..74eea585 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -3,21 +3,132 @@ * Created by leon on 2/9/18. */ public class MainApplication { - private String currentMode = "binary"; - private String currentUnit = "degrees"; - + private static double currentValue = 0.0; // Current Value + private static double memoryValue = 0.0; // Value Stored in Memory + private static String currentMode = "binary"; + private static String currentUnit = "degrees"; + //private String currentMode = "binary"; + //private String currentUnit = "degrees"; 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("What operation would you like to perform?"); + Console.println("ARITHMETIC OPERATIONS: 1-Add 2-Subtract 3-Multiple 4-Divide"); + Console.println("ADVANCED OPERATIONS: 5-Square 6-Square Root 7-Exponentiation 8-Inverse 9-Change Sign 10-Factorial"); + Console.println("TRIG FUNCTIONS: 11-Sine 12-Cosine 13-Tangent"); + Console.println("INVERSE TRIG FUNCTIONS: 14-Inverse Sine 15-Inverse Cosine 16-Inverse Tangent"); + Console.println("SWITCH TRIG UNITS: 17-Switch Trig Units 18-Select Trig Units"); + Console.println("LOGARITHMIC FUNCTIONS: 18-Log 19-Inverse Log 20-Natural Log 21-Inverse Natural Log"); + Console.println("MEMORY FUNCTIONS: 22-Clear memory 23-Add value to memory 24-Recall memory"); + Console.println("DISPLAY CHANGES: 25-Switch Display Mode 26-Choose Display Mode"); + Console.println("99-EXIT CALCULATOR"); + + double userInputDouble = 0.0; + + boolean startLoop = true; + while (startLoop) { + Integer choice = Console.getIntegerInput("Enter the number of the operation you want to perform."); + switch (choice) { + //case 1: + // findSum(); + // break; + // case 2: findDifference(); break; + // case 3: findProduct(); break; + // case 4: findQuotient(); break; + case 10: + userInputDouble = Console.getDoubleInput("Enter a number as a double"); + findFactorial(userInputDouble); + break; + case 17: + switchUnitsMode(); + break; + case 18: + String trigMode = Console.getStringInput("Enter the desired trig units mode"); + switchUnitsMode(trigMode); + break; + case 22: + clearMemory(); + break; + case 23: + addCurrentValueToMemory(); + break; + case 24: + recallMemoryValue(); + break; + case 25: + switchDisplayMode(); + break; + case 26: + String mode = Console.getStringInput("Enter the desired mode"); + switchDisplayMode(mode); + break; + case 98: + userInputDouble = Console.getDoubleInput("Enter a number as a double"); + setCurrentValue(userInputDouble); + break; + case 99: + startLoop = false; + System.out.println("Goodbye"); + break; + default: + System.out.println("Invalid choice! Please enter a valid number."); + break; + } + } + } + + // MEMORY + // public static Double acceptUserInput() + + // Set the current value + public static double setCurrentValue(double input) { + currentValue = input; + //System.out.println(currentValue); + return currentValue; + } + + // Return the current value + public static double returnCurrentValue() { + return currentValue; + } + + // M+ KEY: Recall current value from memory to the display + public static double recallMemoryValue() { + System.out.println(memoryValue); + return memoryValue; + } + + // MC KEY: Reset the memory & Clear Display + public static double clearMemory() { + memoryValue = 0.0; + System.out.println(memoryValue); + return memoryValue; + } + + + // MC+ KEY: Add currently displayed value to the value in memory & clear display + public static double addCurrentValueToMemory() { + memoryValue = currentValue; + currentValue = 0.0; + System.out.println(currentValue); + return currentValue; + } + + // BASIC CALCULATOR OPERATIONS + - 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); + // SCIENTIFIC CALCULATOR OPERATIONS + // Find the factorial of a number + public static double findFactorial(double userInput) { + double factorial = userInput; + for (int i = 1; i < factorial; i++) { + userInput *= i; + } + setCurrentValue(userInput); + System.out.println(currentValue); + return currentValue; } @@ -63,6 +174,7 @@ public double invNatLog(double num1) { } + //DISPLAY CHANGES public void getMode() { @@ -70,7 +182,11 @@ public void getMode() { } //public void setMode(String newMode){currentMode = newMode;} + + public static String switchDisplayMode(){ + public String switchDisplayMode(){ + if (currentMode.equals("binary")) { currentMode = "octal"; System.out.println("octal"); @@ -84,11 +200,16 @@ public String switchDisplayMode(){ currentMode = "binary"; System.out.println("binary"); } else System.out.println("Err"); + return currentMode; + } - return currentMode; + public static String switchDisplayMode(String mode) { + + return currentMode; } public String switchDisplayMode(String mode) { + if (mode.equals("binary")) { currentMode = "binary"; } else if (mode.equals("octal")) { @@ -104,11 +225,19 @@ public String switchDisplayMode(String mode) { //UNIT CHANGES + + public static void getUnit() { + System.out.println(currentUnit); + } + + public static String switchUnitsMode(){ + public void getUnit() { System.out.println(currentUnit); } public String switchUnitsMode(){ + if (currentUnit.equals("degrees")) { currentUnit = "radians"; System.out.println("radians"); @@ -120,17 +249,25 @@ public String switchUnitsMode(){ return currentUnit; } + + public static String switchUnitsMode(String mode) { + public String switchUnitsMode(String mode) { + if (mode.equals("degrees")) { currentUnit = "degrees"; } else if (mode.equals("radians")) { currentUnit = "radians"; } else mode = "Err"; + + System.out.println(mode); + System.out.println(mode); + return mode; } - } + diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 473437d9..96e15f5a 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,4 +1,6 @@ package com.zipcodewilmington.scientific_calculator; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; import com.zipcodewilmington.scientificcalculator.MainApplication; import org.junit.Test; import static org.junit.Assert.assertEquals; @@ -9,8 +11,11 @@ import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; - - +import com.zipcodewilmington.scientificcalculator.MainApplication; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; /** * Created by leon on 2/9/18. */ @@ -128,6 +133,34 @@ public void unitChange() { } + @Test + public void findFactorial() { + MainApplication findFactorialTest = new MainApplication(); + + assertEquals(120.0, findFactorialTest.findFactorial(5.0), 1e-15); + assertEquals(362880, findFactorialTest.findFactorial(9), 1e-15); + assertEquals(6.0, findFactorialTest.findFactorial(3.0), 1e-15); + } + + @Test + public void setCurrentValue() { + MainApplication setCurrentValueTest = new MainApplication(); + + assertEquals(10, setCurrentValueTest.setCurrentValue(10), 1e-15); + assertEquals(21.1, setCurrentValueTest.setCurrentValue(21.1), 1e-15); + assertNotEquals(5.0, setCurrentValueTest.setCurrentValue(5.1), 1e-15); + } + + @Test + public void clearMemory() { + MainApplication clearMemoryTest = new MainApplication(); + + assertEquals(0, clearMemoryTest.clearMemory(), 1e-15); + assertEquals(0, clearMemoryTest.clearMemory(), 1e-15); + assertNotEquals(5.0, clearMemoryTest.clearMemory(), 1e-15); + } + + From aa03d7f549468e59dcd859904cd2662ee6c4df1b Mon Sep 17 00:00:00 2001 From: Lena Date: Sat, 27 Feb 2021 21:49:39 -0500 Subject: [PATCH 05/15] Lenasbranch (#6) added trig functions Co-authored-by: xyuan04 <78838190+xyuan04@users.noreply.github.com> --- pom.xml | 29 ----- .../scientificcalculator/MainApplication.java | 120 ++++++++++++++++++ .../TestMainApplication.java | 51 ++++++++ 3 files changed, 171 insertions(+), 29 deletions(-) diff --git a/pom.xml b/pom.xml index 278cdf18..4cf506b5 100644 --- a/pom.xml +++ b/pom.xml @@ -29,33 +29,4 @@ - - - - - junit - junit - 4.12 - test - - - junit - junit - 4.12 - test - - - junit - junit - 4.12 - test - - - junit - junit - 4.12 - test - - - \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 74eea585..2fdd725f 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -3,6 +3,9 @@ * Created by leon on 2/9/18. */ public class MainApplication { + + private String currentMode = "binary"; + private String currentUnit = "degrees"; private static double currentValue = 0.0; // Current Value private static double memoryValue = 0.0; // Value Stored in Memory private static String currentMode = "binary"; @@ -11,6 +14,7 @@ public class MainApplication { //private String currentUnit = "degrees"; public static void main(String[] args) { + Console.println("Welcome to my calculator!"); Console.println("What operation would you like to perform?"); Console.println("ARITHMETIC OPERATIONS: 1-Add 2-Subtract 3-Multiple 4-Divide"); @@ -226,6 +230,122 @@ public String switchDisplayMode(String mode) { //UNIT CHANGES + } + //DISPLAY CHANGES + + public void getMode() { + System.out.println(currentMode); + } + //public void setMode(String newMode){currentMode = newMode;} + + public String switchDisplayMode(){ + if (currentMode.equals("binary")) { + currentMode = "octal"; + System.out.println("octal"); + } else if (currentMode.equals("octal")) { + currentMode = "decimal"; + System.out.println("decimal"); + } else if (currentMode.equals("decimal")) { + currentMode = "hexadecimal"; + System.out.println("hexadecimal"); + } else if (currentMode.equals("hexadecimal")) { + currentMode = "binary"; + System.out.println("binary"); + } else System.out.println("Err"); + + return currentMode; + } + + public String switchDisplayMode(String mode) { + if (mode.equals("binary")) { + currentMode = "binary"; + } else if (mode.equals("octal")) { + currentMode = "octal"; + } else if (mode.equals("decimal")) { + currentMode = "decimal"; + } else if (mode.equals("hexadecimal")) { + currentMode = "hexadecimal"; + } else mode = "Err"; + System.out.println(mode); + return mode; + } + + //UNIT CHANGES + + public void getUnit() { + System.out.println(currentUnit); + } + + public String switchUnitsMode(){ + if (currentUnit.equals("degrees")) { + currentUnit = "radians"; + System.out.println("radians"); + } else if (currentUnit.equals("radians")) { + currentUnit = "degrees"; + System.out.println("degrees"); + } else System.out.println("Err"); + + return currentUnit; + } + + public String switchUnitsMode(String mode) { + if (mode.equals("degrees")) { + currentUnit = "degrees"; + } else if (mode.equals("radians")) { + currentUnit = "radians"; + } else mode = "Err"; + System.out.println(mode); + return mode; + } + // TRIG FUNCTIONS + public static double getSin (double a){ + + double b=Math.toRadians(a); + + return (Math.sin(b)); + } + + + public static double getCos(double a){ + + double b=Math.toRadians(a); + System.out.println(Math.cos(b)); + return (Math.cos(b)); + } + + public static double getTan(double a){ + + double b=Math.toRadians(a); + + return (Math.tan(b)); + } + + public static double getAsinPi(double a) { + + return (Math.asin(a)); + } + public static double getAsin(double a) { + + double b=Math.toRadians(a); + + return (Math.asin(b)); + } + + public static double getAcos (double a){ + + double b=Math.toRadians(a); + + return (Math.acos(b)); + } + + public static double getAtan (double a){ + + return (Math.atan(a)); + } + + +} + public static void getUnit() { System.out.println(currentUnit); } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 96e15f5a..952ae030 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,5 +1,10 @@ package com.zipcodewilmington.scientific_calculator; import static org.junit.Assert.assertEquals; +import com.zipcodewilmington.scientificcalculator.MainApplication; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; +import javax.naming.NameNotFoundException; import static org.junit.Assert.assertNotEquals; import com.zipcodewilmington.scientificcalculator.MainApplication; import org.junit.Test; @@ -96,6 +101,7 @@ public void getInvNetLog() { } + @Test public void displayTest() { MainApplication displaytester = new MainApplication(); @@ -132,6 +138,50 @@ public void unitChange() { assertEquals("degrees", unitChanger1.switchUnitsMode("degrees")); } + @Test + public void sinTest() { + MainApplication sinTest1 = new MainApplication(); + assertEquals(-1, sinTest1.getSin(270.0),0.000000001); + assertEquals(0.5, sinTest1.getSin(30.0),0.000000001); + assertEquals(1.0, sinTest1.getSin(90.0),0.000000001); + //assertEquals(Float.NaN, sinTest1.getSin(30.0),0.000000001); + } + @Test + public void cosTest() { + MainApplication cosTest1 = new MainApplication(); + assertEquals(0.866025,cosTest1.getCos(30.0),0.000001); + } + @Test + public void tanTest() { + MainApplication tanTest1 = new MainApplication(); + assertEquals(0,tanTest1.getTan(0.0),0.001); + } + @Test + public void asinpiTest(){ + MainApplication asinTest1 = new MainApplication(); + assertEquals(Float.NaN,asinTest1.getAsinPi(Math.PI),0.000001); + assertEquals(Float.NaN,asinTest1.getAsinPi(Double.NEGATIVE_INFINITY),0.000001); + } + @Test + public void asinTest(){ + MainApplication asinTest1 = new MainApplication(); + assertEquals(0.0,asinTest1.getAsin(0.0),0.000001); + } + @Test + public void acosTest(){ + MainApplication acosTest1 = new MainApplication(); + assertEquals(1.5533,acosTest1.getAcos(1.0),0.001); + + } + @Test + public void atanTest(){ + MainApplication atanTest1 = new MainApplication(); + assertEquals(0.0,atanTest1.getAtan(0.0), 0.01); + } + +} + + @Test public void findFactorial() { @@ -166,3 +216,4 @@ public void clearMemory() { } + From 467dc9c53d198ffd9ba9afe5a741259d01b23939 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Sat, 27 Feb 2021 23:09:12 -0500 Subject: [PATCH 06/15] deleted duplicate code (#7) Co-authored-by: xiong --- .../scientificcalculator/MainApplication.java | 158 +++--------------- .../TestMainApplication.java | 20 +-- 2 files changed, 25 insertions(+), 153 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 2fdd725f..f05e7b98 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -3,15 +3,11 @@ * Created by leon on 2/9/18. */ public class MainApplication { - - private String currentMode = "binary"; - private String currentUnit = "degrees"; - private static double currentValue = 0.0; // Current Value - private static double memoryValue = 0.0; // Value Stored in Memory + public static boolean startLoop = true; private static String currentMode = "binary"; private static String currentUnit = "degrees"; - //private String currentMode = "binary"; - //private String currentUnit = "degrees"; + private static double currentValue = 0.0; // Current Value + private static double memoryValue = 0.0; // Value Stored in Memory public static void main(String[] args) { @@ -27,9 +23,6 @@ public static void main(String[] args) { Console.println("DISPLAY CHANGES: 25-Switch Display Mode 26-Choose Display Mode"); Console.println("99-EXIT CALCULATOR"); - double userInputDouble = 0.0; - - boolean startLoop = true; while (startLoop) { Integer choice = Console.getIntegerInput("Enter the number of the operation you want to perform."); switch (choice) { @@ -81,6 +74,10 @@ public static void main(String[] args) { } } + static double userInputDouble = 0.0; + + + // MEMORY // public static Double acceptUserInput() @@ -150,28 +147,22 @@ public static double logarithm(double num1) { //Inverted Logs - public double invLog(double num1) { + public static double invLog(double num1) { double newNum = Math.pow(10,num1); System.out.println(newNum); return newNum; } //Natural Logs - public double natLog(double num1) { + public static double natLog(double num1) { double newNum = Math.log(num1); System.out.println(newNum); return newNum; } //Inverted Natural Logs - } - public double natLog(double num1) { - double newNum = Math.log(num1); - System.out.println(newNum); - return newNum; - } - public double invNatLog(double num1) { + public static double invNatLog(double num1) { double newNum = Math.pow(Math.E,num1); System.out.println(newNum); return newNum; @@ -181,15 +172,12 @@ public double invNatLog(double num1) { //DISPLAY CHANGES - public void getMode() { + public static void getMode() { System.out.println(currentMode); } //public void setMode(String newMode){currentMode = newMode;} - - public static String switchDisplayMode(){ - - public String switchDisplayMode(){ + public static String switchDisplayMode() { if (currentMode.equals("binary")) { currentMode = "octal"; @@ -207,56 +195,9 @@ public String switchDisplayMode(){ return currentMode; } - public static String switchDisplayMode(String mode) { - - return currentMode; - } - - public String switchDisplayMode(String mode) { - - if (mode.equals("binary")) { - currentMode = "binary"; - } else if (mode.equals("octal")) { - currentMode = "octal"; - } else if (mode.equals("decimal")) { - currentMode = "decimal"; - } else if (mode.equals("hexadecimal")) { - currentMode = "hexadecimal"; - } else mode = "Err"; - System.out.println(mode); - return mode; - } - - //UNIT CHANGES - - - } - //DISPLAY CHANGES - - public void getMode() { - System.out.println(currentMode); - } - //public void setMode(String newMode){currentMode = newMode;} - - public String switchDisplayMode(){ - if (currentMode.equals("binary")) { - currentMode = "octal"; - System.out.println("octal"); - } else if (currentMode.equals("octal")) { - currentMode = "decimal"; - System.out.println("decimal"); - } else if (currentMode.equals("decimal")) { - currentMode = "hexadecimal"; - System.out.println("hexadecimal"); - } else if (currentMode.equals("hexadecimal")) { - currentMode = "binary"; - System.out.println("binary"); - } else System.out.println("Err"); - return currentMode; - } + public static String switchDisplayMode(String mode) { - public String switchDisplayMode(String mode) { if (mode.equals("binary")) { currentMode = "binary"; } else if (mode.equals("octal")) { @@ -272,11 +213,11 @@ public String switchDisplayMode(String mode) { //UNIT CHANGES - public void getUnit() { + public static void getUnit() { System.out.println(currentUnit); } - public String switchUnitsMode(){ + public static String switchUnitsMode() { if (currentUnit.equals("degrees")) { currentUnit = "radians"; System.out.println("radians"); @@ -288,7 +229,7 @@ public String switchUnitsMode(){ return currentUnit; } - public String switchUnitsMode(String mode) { + public static String switchUnitsMode(String mode) { if (mode.equals("degrees")) { currentUnit = "degrees"; } else if (mode.equals("radians")) { @@ -298,96 +239,45 @@ public String switchUnitsMode(String mode) { return mode; } // TRIG FUNCTIONS - public static double getSin (double a){ + public static double getSin (double a) { double b=Math.toRadians(a); - return (Math.sin(b)); } - public static double getCos(double a){ - + public static double getCos(double a) { double b=Math.toRadians(a); System.out.println(Math.cos(b)); return (Math.cos(b)); } - public static double getTan(double a){ - + public static double getTan(double a) { double b=Math.toRadians(a); - return (Math.tan(b)); } public static double getAsinPi(double a) { - return (Math.asin(a)); } - public static double getAsin(double a) { + public double getAsin(double a) { double b=Math.toRadians(a); - return (Math.asin(b)); } - public static double getAcos (double a){ - + public double getAcos (double a){ double b=Math.toRadians(a); - return (Math.acos(b)); } - public static double getAtan (double a){ - + public double getAtan (double a){ return (Math.atan(a)); } -} - - public static void getUnit() { - System.out.println(currentUnit); - } - - public static String switchUnitsMode(){ - - public void getUnit() { - System.out.println(currentUnit); + public boolean isStartLoop() { + return startLoop; } - - public String switchUnitsMode(){ - - if (currentUnit.equals("degrees")) { - currentUnit = "radians"; - System.out.println("radians"); - } else if (currentUnit.equals("radians")) { - currentUnit = "degrees"; - System.out.println("degrees"); - } else System.out.println("Err"); - - return currentUnit; - } - - - public static String switchUnitsMode(String mode) { - - public String switchUnitsMode(String mode) { - - if (mode.equals("degrees")) { - currentUnit = "degrees"; - } else if (mode.equals("radians")) { - currentUnit = "radians"; - } else mode = "Err"; - - System.out.println(mode); - - System.out.println(mode); - - return mode; - } - - - } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 952ae030..d14e8eea 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -6,21 +6,7 @@ import org.junit.Test; import javax.naming.NameNotFoundException; import static org.junit.Assert.assertNotEquals; -import com.zipcodewilmington.scientificcalculator.MainApplication; -import org.junit.Test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertEquals; -import com.zipcodewilmington.scientificcalculator.MainApplication; -import org.junit.Test; import static org.junit.Assert.*; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.Test; -import com.zipcodewilmington.scientificcalculator.MainApplication; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; /** * Created by leon on 2/9/18. */ @@ -70,6 +56,7 @@ public void getInvNatLog0() { assertEquals(0.3678794412, newLog.invNatLog(-1.0), 0.0000001); assertEquals(1.105170918, newLog.invNatLog(0.1), 0.0000001); assertEquals(0.904837418, newLog.invNatLog(-0.1), 0.0000001); + } @Test //Log base 10 method test @@ -179,9 +166,6 @@ public void atanTest(){ assertEquals(0.0,atanTest1.getAtan(0.0), 0.01); } -} - - @Test public void findFactorial() { @@ -213,7 +197,5 @@ public void clearMemory() { - - } From c873109cb5c7c6efd28bfa293dc0fbbbbdd2512d Mon Sep 17 00:00:00 2001 From: Jorge Date: Sun, 28 Feb 2021 09:20:02 -0500 Subject: [PATCH 07/15] cleaned up testClass --- .../TestMainApplication.java | 29 ------------------- 1 file changed, 29 deletions(-) diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index d14e8eea..96ba8f20 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -59,35 +59,6 @@ public void getInvNatLog0() { } - @Test //Log base 10 method test - public void getLog10() { - MainApplication newLog = new MainApplication(); - assertEquals(1.0, newLog.logarithm(10.0), 0.0000001); - } - @Test //Log base 10 method Err test - public void getLog101() { - MainApplication newLog = new MainApplication(); - assertEquals(Double. NEGATIVE_INFINITY, newLog.logarithm(0.0), 0.0000001); - } - - - @Test //Inverted log test - public void getInvLog10() { - MainApplication newLog = new MainApplication(); - assertEquals(100000.0, newLog.invLog(5.0), 0.0000001); - } - @Test //Natural Log test - public void getNetLog() { - MainApplication newLog = new MainApplication(); - assertEquals(1.609437912, newLog.natLog(5.0), 0.0000001); - } - @Test //Inverted Natural Log test - public void getInvNetLog() { - MainApplication newLog = new MainApplication(); - assertEquals(148.4131591, newLog.invNatLog(5.0), 0.0000001); - } - - @Test public void displayTest() { From 49a06b743e1391dce3f560780df5eb16bccb2ed4 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Sun, 28 Feb 2021 10:26:38 -0500 Subject: [PATCH 08/15] Branch xiong (#8) added basic functions and tested Co-authored-by: xiong --- .../scientificcalculator/MainApplication.java | 32 ++++++- .../TestMainApplication.java | 87 ++++++++++++++++++- 2 files changed, 117 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index f05e7b98..e89995d9 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -74,13 +74,43 @@ public static void main(String[] args) { } } - static double userInputDouble = 0.0; + public static double userInputDouble = 0.0; + + //IM A BASIC B + public static double findSum(double a, double b) { + currentValue = a + b; + return currentValue; + } + + public static double findDifference(double a, double b) { + currentValue = a - b; + return currentValue; + } + + public static double findProduct(double a, double b) { + currentValue = a * b; + return currentValue; + } + + public static double findQuotient(double a, double b) { + currentValue = a / b; + return currentValue; + } + + public static double findRemainder(double a, double b) { + currentValue = a % b; + return currentValue; + } // MEMORY // public static Double acceptUserInput() + public static double getMemoryValue() { + return memoryValue; + } + // Set the current value public static double setCurrentValue(double input) { currentValue = input; diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 96ba8f20..a46945a8 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -4,6 +4,8 @@ import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; +import org.junit.experimental.theories.suppliers.TestedOn; + import javax.naming.NameNotFoundException; import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.*; @@ -13,6 +15,46 @@ public class TestMainApplication { + //Basic functions tests + @Test + public void getSum() { + MainApplication testSum = new MainApplication(); + assertEquals(10, testSum.findSum(8, 2), 0.0000001); + assertEquals(163.987, testSum.findSum(100, 63.987), 0.0000001); + assertEquals(420, testSum.findSum(69, 351), 0.0000001); + } + + @Test + public void getDifference() { + MainApplication testDiff = new MainApplication(); + assertEquals(8, testDiff.findDifference(15, 7), 0.0000001); + assertEquals(99.9, testDiff.findDifference(100.9, 1), 0.0000001); + assertEquals(69, testDiff.findDifference(420, 351), 0.0000001); + } + + @Test + public void getProduct() { + MainApplication testProduct = new MainApplication(); + assertEquals(100, testProduct.findProduct(10, 10), 0.0000001); + assertEquals(12.5, testProduct.findProduct(2.5, 5), 0.0000001); + assertEquals(28980, testProduct.findProduct(69, 420), 0.0000001); + } + + @Test + public void getQuotient() { + MainApplication testQuotient = new MainApplication(); + assertEquals(10, testQuotient.findQuotient(100, 10), 0.0000001); + assertEquals(33.3, testQuotient.findQuotient(99.9, 3), 0.0000001); + assertEquals(6.0869565, testQuotient.findQuotient(420, 69), 0.0000001); + } + + @Test + public void getRemainder() { + MainApplication testRemainder = new MainApplication(); + assertEquals(1, testRemainder.findRemainder(17, 2), 0.0000001); + assertEquals(3, testRemainder.findRemainder(23, 5), 0.0000001); + assertEquals(0, testRemainder.findRemainder(420, 2), 0.0000001); + } //Log base 10 method tests @Test @@ -56,6 +98,36 @@ public void getInvNatLog0() { assertEquals(0.3678794412, newLog.invNatLog(-1.0), 0.0000001); assertEquals(1.105170918, newLog.invNatLog(0.1), 0.0000001); assertEquals(0.904837418, newLog.invNatLog(-0.1), 0.0000001); + + } + + + @Test //Log base 10 method test + public void getLog10() { + MainApplication newLog = new MainApplication(); + assertEquals(1.0, newLog.logarithm(10.0), 0.0000001); + } + @Test //Log base 10 method Err test + public void getLog101() { + MainApplication newLog = new MainApplication(); + assertEquals(Double. NEGATIVE_INFINITY, newLog.logarithm(0.0), 0.0000001); + } + + + @Test //Inverted log test + public void getInvLog10() { + MainApplication newLog = new MainApplication(); + assertEquals(100000.0, newLog.invLog(5.0), 0.0000001); + } + @Test //Natural Log test + public void getNetLog() { + MainApplication newLog = new MainApplication(); + assertEquals(1.609437912, newLog.natLog(5.0), 0.0000001); + } + @Test //Inverted Natural Log test + public void getInvNetLog() { + MainApplication newLog = new MainApplication(); + assertEquals(148.4131591, newLog.invNatLog(5.0), 0.0000001); } @@ -63,7 +135,7 @@ public void getInvNatLog0() { @Test public void displayTest() { MainApplication displaytester = new MainApplication(); - + assertEquals("binary", displaytester.switchDisplayMode()); assertEquals("octal", displaytester.switchDisplayMode()); assertEquals("decimal", displaytester.switchDisplayMode()); assertEquals("hexadecimal", displaytester.switchDisplayMode()); @@ -159,12 +231,25 @@ public void setCurrentValue() { @Test public void clearMemory() { MainApplication clearMemoryTest = new MainApplication(); + clearMemoryTest.setCurrentValue(420); + assertEquals(0, clearMemoryTest.addCurrentValueToMemory(), 1e-15); + assertEquals(420, clearMemoryTest.getMemoryValue(), 1e-15); assertEquals(0, clearMemoryTest.clearMemory(), 1e-15); assertEquals(0, clearMemoryTest.clearMemory(), 1e-15); assertNotEquals(5.0, clearMemoryTest.clearMemory(), 1e-15); } + @Test + public void testStoredMemory() { + MainApplication addMemTest = new MainApplication(); + addMemTest.setCurrentValue(6.0); + + assertEquals(6.0, addMemTest.returnCurrentValue(), 1e-15); + assertEquals(0.0, addMemTest.addCurrentValueToMemory(), 1e-15); + assertEquals(6.0, addMemTest.recallMemoryValue(), 1e-15); + } + From ca71b63d875df94e977bf66b36b36a7999da2c60 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Sun, 28 Feb 2021 16:26:14 -0500 Subject: [PATCH 09/15] Branch xiong (#9) * added rock,paper,sci game/updated code Co-authored-by: xiong --- .../scientificcalculator/MainApplication.java | 310 +++++++++++++++--- .../scientificcalculator/NewCalculator.java | 18 +- .../TestMainApplication.java | 1 + 3 files changed, 275 insertions(+), 54 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index e89995d9..09cc9fea 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,4 +1,7 @@ package com.zipcodewilmington.scientificcalculator; + +import com.sun.codemodel.internal.JWhileLoop; + /** * Created by leon on 2/9/18. */ @@ -8,34 +11,90 @@ public class MainApplication { private static String currentUnit = "degrees"; private static double currentValue = 0.0; // Current Value private static double memoryValue = 0.0; // Value Stored in Memory + private static String displayValue = ""; //String.valueOf(currentValue) + public static void main(String[] args) { Console.println("Welcome to my calculator!"); Console.println("What operation would you like to perform?"); - Console.println("ARITHMETIC OPERATIONS: 1-Add 2-Subtract 3-Multiple 4-Divide"); - Console.println("ADVANCED OPERATIONS: 5-Square 6-Square Root 7-Exponentiation 8-Inverse 9-Change Sign 10-Factorial"); - Console.println("TRIG FUNCTIONS: 11-Sine 12-Cosine 13-Tangent"); - Console.println("INVERSE TRIG FUNCTIONS: 14-Inverse Sine 15-Inverse Cosine 16-Inverse Tangent"); - Console.println("SWITCH TRIG UNITS: 17-Switch Trig Units 18-Select Trig Units"); - Console.println("LOGARITHMIC FUNCTIONS: 18-Log 19-Inverse Log 20-Natural Log 21-Inverse Natural Log"); - Console.println("MEMORY FUNCTIONS: 22-Clear memory 23-Add value to memory 24-Recall memory"); - Console.println("DISPLAY CHANGES: 25-Switch Display Mode 26-Choose Display Mode"); - Console.println("99-EXIT CALCULATOR"); while (startLoop) { + Console.println("SYSTEM OPERATIONS: 0-Clear Display"); + Console.println("ARITHMETIC OPERATIONS: 1-Add 2-Subtract 3-Multiple 4-Divide"); + Console.println("ADVANCED OPERATIONS: 5-Square 6-Square Root 7-Exponentiation 8-Inverse 9-Change Sign 10-Factorial"); + Console.println("TRIG FUNCTIONS: 11-Sine 12-Cosine 13-Tangent"); + Console.println("INVERSE TRIG FUNCTIONS: 14-Inverse Sine 15-Inverse Cosine 16-Inverse Tangent"); + Console.println("SWITCH TRIG UNITS: 17-Switch Trig Units 18-Select Trig Units"); + Console.println("LOGARITHMIC FUNCTIONS: 19-Log 20-Inverse Log 21-Natural Log 22-Inverse Natural Log"); + Console.println("MEMORY FUNCTIONS: 23-Clear memory 24-Add value to memory 25-Recall memory"); + Console.println("DISPLAY CHANGES: 26-Switch Display Mode 27-Choose Display Mode"); + Console.println("99-EXIT CALCULATOR"); + Integer choice = Console.getIntegerInput("Enter the number of the operation you want to perform."); + switch (choice) { - //case 1: - // findSum(); - // break; - // case 2: findDifference(); break; - // case 3: findProduct(); break; - // case 4: findQuotient(); break; + case 0: + clearDisplay(); + System.out.println(displayValue); + case 1: + userInputDouble = Console.getDoubleInput("Enter first number"); + userInputDouble2 = Console.getDoubleInput("Enter second number"); + findSum(userInputDouble, userInputDouble2); + System.out.println(displayValue); + break; + case 2: + userInputDouble = Console.getDoubleInput("Enter first number"); + userInputDouble2 = Console.getDoubleInput("Enter second number"); + findDifference(userInputDouble, userInputDouble2); + System.out.println(displayValue); + break; + case 3: + userInputDouble = Console.getDoubleInput("Enter first number"); + userInputDouble2 = Console.getDoubleInput("Enter second number"); + findProduct(userInputDouble, userInputDouble2); + System.out.println(displayValue); + break; + case 4: + userInputDouble = Console.getDoubleInput("Enter first number"); + userInputDouble2 = Console.getDoubleInput("Enter second number"); + findQuotient(userInputDouble, userInputDouble2); + System.out.println(displayValue); + break; case 10: - userInputDouble = Console.getDoubleInput("Enter a number as a double"); + userInputDouble = Console.getDoubleInput("Enter a number"); findFactorial(userInputDouble); break; + case 11: + userInputDouble = Console.getDoubleInput("Enter a number"); + getSin(userInputDouble); + System.out.println(displayValue); + break; + case 12: + userInputDouble = Console.getDoubleInput("Enter a number"); + getCos(userInputDouble); + System.out.println(displayValue); + break; + case 13: + userInputDouble = Console.getDoubleInput("Enter a number"); + getTan(userInputDouble); + System.out.println(displayValue); + break; + case 14: + userInputDouble = Console.getDoubleInput("Enter a number"); + getAsin(userInputDouble); + System.out.println(displayValue); + break; + case 15: + userInputDouble = Console.getDoubleInput("Enter a number"); + getAcos(userInputDouble); + System.out.println(displayValue); + break; + case 16: + userInputDouble = Console.getDoubleInput("Enter a number"); + getAtan(userInputDouble); + System.out.println(displayValue); + break; case 17: switchUnitsMode(); break; @@ -43,19 +102,39 @@ public static void main(String[] args) { String trigMode = Console.getStringInput("Enter the desired trig units mode"); switchUnitsMode(trigMode); break; + case 19: + userInputDouble = Console.getDoubleInput("Enter a number"); + logarithm(userInputDouble); + System.out.println(displayValue); + break; + case 20: + userInputDouble = Console.getDoubleInput("Enter a number"); + invLog(userInputDouble); + System.out.println(displayValue); + break; + case 21: + userInputDouble = Console.getDoubleInput("Enter a number"); + natLog(userInputDouble); + System.out.println(displayValue); + break; case 22: - clearMemory(); + userInputDouble = Console.getDoubleInput("Enter a number"); + invNatLog(userInputDouble); + System.out.println(displayValue); break; case 23: - addCurrentValueToMemory(); + clearMemory(); break; case 24: - recallMemoryValue(); + addCurrentValueToMemory(); break; case 25: - switchDisplayMode(); + recallMemoryValue(); break; case 26: + switchDisplayMode(); + break; + case 27: String mode = Console.getStringInput("Enter the desired mode"); switchDisplayMode(mode); break; @@ -67,6 +146,9 @@ public static void main(String[] args) { startLoop = false; System.out.println("Goodbye"); break; + case 100: + playGame(); + break; default: System.out.println("Invalid choice! Please enter a valid number."); break; @@ -76,55 +158,71 @@ public static void main(String[] args) { public static double userInputDouble = 0.0; + public static double userInputDouble2 = 0; + + public static void clearDisplay(){ + displayValue = "0.0"; + } + //IM A BASIC B public static double findSum(double a, double b) { currentValue = a + b; + displayValue = String.valueOf(currentValue); return currentValue; } public static double findDifference(double a, double b) { currentValue = a - b; + displayValue = String.valueOf(currentValue); return currentValue; } public static double findProduct(double a, double b) { currentValue = a * b; + displayValue = String.valueOf(currentValue); return currentValue; } public static double findQuotient(double a, double b) { + if (b != 0){ + currentValue = a / b; + displayValue = String.valueOf(currentValue); + } else displayValue = "Err"; currentValue = a / b; return currentValue; } public static double findRemainder(double a, double b) { currentValue = a % b; + displayValue = String.valueOf(currentValue); return currentValue; } - - // MEMORY // public static Double acceptUserInput() public static double getMemoryValue() { + displayValue = String.valueOf(memoryValue); return memoryValue; } // Set the current value public static double setCurrentValue(double input) { currentValue = input; + displayValue = String.valueOf(currentValue); //System.out.println(currentValue); return currentValue; } // Return the current value public static double returnCurrentValue() { + displayValue = String.valueOf(currentValue); return currentValue; } // M+ KEY: Recall current value from memory to the display public static double recallMemoryValue() { + displayValue = String.valueOf(memoryValue); System.out.println(memoryValue); return memoryValue; } @@ -132,6 +230,7 @@ public static double recallMemoryValue() { // MC KEY: Reset the memory & Clear Display public static double clearMemory() { memoryValue = 0.0; + displayValue = String.valueOf(memoryValue); System.out.println(memoryValue); return memoryValue; } @@ -141,6 +240,7 @@ public static double clearMemory() { public static double addCurrentValueToMemory() { memoryValue = currentValue; currentValue = 0.0; + displayValue = String.valueOf(currentValue); System.out.println(currentValue); return currentValue; } @@ -158,6 +258,7 @@ public static double findFactorial(double userInput) { } setCurrentValue(userInput); + displayValue = String.valueOf(currentValue); System.out.println(currentValue); return currentValue; } @@ -170,6 +271,7 @@ public static double findFactorial(double userInput) { public static double logarithm(double num1) { double newNum = Math.log10(num1); + displayValue = String.valueOf(newNum); System.out.println(newNum); return newNum; } @@ -179,6 +281,7 @@ public static double logarithm(double num1) { public static double invLog(double num1) { double newNum = Math.pow(10,num1); + displayValue = String.valueOf(newNum); System.out.println(newNum); return newNum; @@ -186,6 +289,7 @@ public static double invLog(double num1) { //Natural Logs public static double natLog(double num1) { double newNum = Math.log(num1); + displayValue = String.valueOf(newNum); System.out.println(newNum); return newNum; } @@ -194,6 +298,7 @@ public static double natLog(double num1) { public static double invNatLog(double num1) { double newNum = Math.pow(Math.E,num1); + displayValue = String.valueOf(newNum); System.out.println(newNum); return newNum; } @@ -203,6 +308,7 @@ public static double invNatLog(double num1) { //DISPLAY CHANGES public static void getMode() { + displayValue = String.valueOf(currentMode); System.out.println(currentMode); } //public void setMode(String newMode){currentMode = newMode;} @@ -211,17 +317,23 @@ public static String switchDisplayMode() { if (currentMode.equals("binary")) { currentMode = "octal"; + displayValue = currentMode; System.out.println("octal"); } else if (currentMode.equals("octal")) { currentMode = "decimal"; + displayValue = currentMode; System.out.println("decimal"); } else if (currentMode.equals("decimal")) { currentMode = "hexadecimal"; + displayValue = currentMode; System.out.println("hexadecimal"); } else if (currentMode.equals("hexadecimal")) { currentMode = "binary"; + displayValue = currentMode; System.out.println("binary"); - } else System.out.println("Err"); + } else + displayValue = "Err"; + System.out.println("Err"); return currentMode; } @@ -230,13 +342,18 @@ public static String switchDisplayMode(String mode) { if (mode.equals("binary")) { currentMode = "binary"; + displayValue = currentMode; } else if (mode.equals("octal")) { currentMode = "octal"; + displayValue = currentMode; } else if (mode.equals("decimal")) { currentMode = "decimal"; + displayValue = currentMode; } else if (mode.equals("hexadecimal")) { currentMode = "hexadecimal"; + displayValue = currentMode; } else mode = "Err"; + displayValue = mode; System.out.println(mode); return mode; } @@ -244,17 +361,22 @@ public static String switchDisplayMode(String mode) { //UNIT CHANGES public static void getUnit() { + displayValue = currentMode; System.out.println(currentUnit); } public static String switchUnitsMode() { if (currentUnit.equals("degrees")) { currentUnit = "radians"; + displayValue = currentUnit; System.out.println("radians"); } else if (currentUnit.equals("radians")) { currentUnit = "degrees"; + displayValue = currentUnit; System.out.println("degrees"); - } else System.out.println("Err"); + } else + System.out.println("Err"); + displayValue = "Err"; return currentUnit; } @@ -262,9 +384,12 @@ public static String switchUnitsMode() { public static String switchUnitsMode(String mode) { if (mode.equals("degrees")) { currentUnit = "degrees"; + displayValue = currentUnit; } else if (mode.equals("radians")) { currentUnit = "radians"; + displayValue = currentUnit; } else mode = "Err"; + displayValue = mode; System.out.println(mode); return mode; } @@ -272,42 +397,153 @@ public static String switchUnitsMode(String mode) { public static double getSin (double a) { double b=Math.toRadians(a); - return (Math.sin(b)); + currentValue = (Math.sin(b)); + displayValue = String.valueOf(currentValue); + return currentValue; } public static double getCos(double a) { double b=Math.toRadians(a); - System.out.println(Math.cos(b)); - return (Math.cos(b)); + currentValue = (Math.cos(b)); + displayValue = String.valueOf(currentValue); + return currentValue; } public static double getTan(double a) { double b=Math.toRadians(a); - return (Math.tan(b)); + currentValue = (Math.tan(b)); + displayValue = String.valueOf(currentValue); + return currentValue; } public static double getAsinPi(double a) { - return (Math.asin(a)); + currentValue = (Math.asin(a)); + displayValue = String.valueOf(currentValue); + return currentValue; } - public double getAsin(double a) { + public static double getAsin(double a) { double b=Math.toRadians(a); - return (Math.asin(b)); + currentValue = (Math.asin(b)); + displayValue = String.valueOf(currentValue); + return currentValue; } - public double getAcos (double a){ + public static double getAcos (double a){ double b=Math.toRadians(a); - return (Math.acos(b)); - } - - public double getAtan (double a){ - return (Math.atan(a)); + currentValue = (Math.acos(b)); + displayValue = String.valueOf(currentValue); + return currentValue; } + public static double getAtan (double a){ + currentValue = (Math.atan(a)); + displayValue = String.valueOf(currentValue); + return currentValue; + public boolean isStartLoop() { return startLoop; } + + //'Rock,Paper,Scissors' game. + public static void playGame() { + boolean gameOn = true; + double userChoice = 0; + double continueGame = 0; + double score = 0; + double gamesPlayed = 0; + String computerMove = ""; + String userMove = ""; + + + + while(gameOn) { + System.out.println("Let's play a game!"); + System.out.println("0 = Rock, 1 = Paper, 2 = Scissors"); + userChoice = Console.getDoubleInput("Enter your selection."); + + double computerDub = (Math.random() * 3); + + if ((computerDub >= 0) && (computerDub < 1)) { + computerMove = "Rock"; + } else if ((computerDub >= 1) && (computerDub < 2)) { + computerMove = "Paper"; + } else if ((computerDub >= 2) && (computerDub < 3)) { + computerMove = "Scissors"; + } else { + computerMove = "Invalid, choose 0,1,2"; + } + + if (userChoice == 0) { + userMove = "Rock"; + } else if (userChoice == 1) { + userMove = "Paper"; + } else if (userChoice == 2) { + userMove = "Scissors"; + } else { + System.out.println("Invalid, choose 0,1,2"); continue; + } + //System.out.println(computerDub); + + System.out.println("You play: " + userMove); + System.out.println("I play: " + computerMove); + int computerInt = (int) computerDub; + int userInt = (int) userChoice; + + switch (userInt) { + case 0: + if (userInt == computerInt) { + System.out.println("We tied!"); + } else if (computerInt == 1) { + System.out.println("Sorry, you lose!"); + } else { score++; + System.out.println("Congratulations, you win!"); + } + break; + case 1: + if (userInt == computerInt) { + System.out.println("We tied!"); + } else if (computerInt == 0) { + score++; + System.out.println("Congratulations, you win!"); + } else { + System.out.println("Sorry! You lose!"); + } + break; + case 2: + if (userInt == computerInt) { + System.out.println("We tied"); + } else if (computerInt == 0) { + System.out.println("Sorry, you lose!"); + } else { + score++; + System.out.println("Congratulations, you win!"); + } + break; + + } + gamesPlayed++; + + System.out.println("You won " + score + " / " + gamesPlayed + "!"); + System.out.println("Play again? 1 - Yes or 2 - No"); + continueGame = Console.getDoubleInput("Enter your selection."); + + boolean validInput = true; + while (validInput) { + if (continueGame == 1) { + gameOn = true; + break; + } else if (continueGame == 2) { + gameOn = false; + break; + } else System.out.println("Invalid selection: Please choose 1 - Yes or 2 - No"); + continueGame = Console.getDoubleInput(""); + } + + } + + } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java index e7c41c40..b0a77485 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java @@ -4,23 +4,7 @@ public class NewCalculator { static MainApplication calculator = new MainApplication(); public static void main(String[] args) { - calculator.switchDisplayMode(); - calculator.switchDisplayMode(); - calculator.switchDisplayMode(); - calculator.switchDisplayMode("Hellow"); - calculator.switchDisplayMode("binary"); - calculator.switchDisplayMode(); - - calculator.getMode(); - - calculator.switchUnitsMode(); - calculator.switchUnitsMode("degrees"); - calculator.switchUnitsMode(); - calculator.switchUnitsMode(); - calculator.switchUnitsMode("radians"); - calculator.switchUnitsMode("Break me"); - calculator.switchUnitsMode(); - calculator.switchUnitsMode(); + calculator.playGame(); } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index a46945a8..62e64237 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -98,6 +98,7 @@ public void getInvNatLog0() { assertEquals(0.3678794412, newLog.invNatLog(-1.0), 0.0000001); assertEquals(1.105170918, newLog.invNatLog(0.1), 0.0000001); assertEquals(0.904837418, newLog.invNatLog(-0.1), 0.0000001); + } } From e180b403e1b837030948f0a34488674cbd2e5c7d Mon Sep 17 00:00:00 2001 From: Lena Date: Sun, 28 Feb 2021 16:42:57 -0500 Subject: [PATCH 10/15] Lenasbranch (#10) * final changes Co-authored-by: xyuan04 <78838190+xyuan04@users.noreply.github.com> --- .DS_Store | Bin 6148 -> 6148 bytes .../scientificcalculator/MainApplication.java | 13 ++++++- .../TestMainApplication.java | 35 +++++++++++++++++- 3 files changed, 46 insertions(+), 2 deletions(-) diff --git a/.DS_Store b/.DS_Store index 6825f185360cf00ca3df4055d3183f646f55291e..7e005e5729078d0ad531ba8177b0dc3c1bfd6a4a 100644 GIT binary patch delta 71 zcmZoMXfc=|#>B)qu~2NHo+2ab#(>?7jI5J+Sdup%WRYgvEW#noGO;0RGdl-A2T<8& ZL5}atlles)IT(O|k%56_bA-qmW&nl^5LN&H delta 180 zcmZoMXfc=|#>B!ku~2NHo+2ar#(>?7ix)66F|tqQVM=zEWGH4xX2@hnWyoVF0n%we zoXijp#EA?!K(Z7_CIV&h8HyP6fO5GEIi5NB$w@i+Nem1O0t^g{t(y~=v>4UdfQk}< ziqe5bm7pp43{Px# diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 09cc9fea..962148e9 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -401,7 +401,12 @@ public static double getSin (double a) { displayValue = String.valueOf(currentValue); return currentValue; } - + + public static double getSinPi (double a) { + //double b=Math.toRadians(a); + System.out.println(Math.sin(a)); + return (Math.sin(a)); + } public static double getCos(double a) { double b=Math.toRadians(a); @@ -410,6 +415,12 @@ public static double getCos(double a) { return currentValue; } + public static double getCosPi (double a) { + //double b=Math.toRadians(a); + System.out.println(Math.cos(a)); + return (Math.cos(a)); + } + public static double getTan(double a) { double b=Math.toRadians(a); currentValue = (Math.tan(b)); diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 62e64237..b57c79a4 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -178,36 +178,69 @@ public void sinTest() { //assertEquals(Float.NaN, sinTest1.getSin(30.0),0.000000001); } @Test + public void sinpiTest(){ + MainApplication sinpiTest1 = new MainApplication(); + assertEquals(Float.NaN,sinpiTest1.getSinPi(Double.NaN),0.000001); + assertEquals(Float.NaN,sinpiTest1.getSinPi(Double.NEGATIVE_INFINITY),0.000001); + assertEquals(Float.NaN,sinpiTest1.getSinPi(Double.POSITIVE_INFINITY),0.000001);} + @Test public void cosTest() { MainApplication cosTest1 = new MainApplication(); assertEquals(0.866025,cosTest1.getCos(30.0),0.000001); + assertEquals(0.5,cosTest1.getCos(60.0),0.1); + assertEquals(1.0,cosTest1.getCos(0.0),0.1); } + + @Test + public void cospiTest(){ + MainApplication cospiTest1 = new MainApplication(); + assertEquals(Float.NaN,cospiTest1.getCosPi(Double.NaN),0.000001); + assertEquals(Float.NaN,cospiTest1.getCosPi(Double.NEGATIVE_INFINITY),0.000001); + assertEquals(Float.NaN,cospiTest1.getCosPi(Double.POSITIVE_INFINITY),0.000001);} @Test public void tanTest() { MainApplication tanTest1 = new MainApplication(); assertEquals(0,tanTest1.getTan(0.0),0.001); + assertEquals(1,tanTest1.getTan(45.0),0.001); + assertEquals(1.732,tanTest1.getTan(60.0),0.001); + } @Test public void asinpiTest(){ MainApplication asinTest1 = new MainApplication(); assertEquals(Float.NaN,asinTest1.getAsinPi(Math.PI),0.000001); assertEquals(Float.NaN,asinTest1.getAsinPi(Double.NEGATIVE_INFINITY),0.000001); + assertEquals(Float.NaN,asinTest1.getAsinPi(Double.POSITIVE_INFINITY),0.000001); } @Test public void asinTest(){ MainApplication asinTest1 = new MainApplication(); assertEquals(0.0,asinTest1.getAsin(0.0),0.000001); + assertEquals(0.903,asinTest1.getAsin(45),0.001); + assertEquals(-0.903,asinTest1.getAsin(-45),0.001); } @Test public void acosTest(){ MainApplication acosTest1 = new MainApplication(); - assertEquals(1.5533,acosTest1.getAcos(1.0),0.001); + assertEquals(0.2840,acosTest1.getAcos(55),0.0001); + assertEquals(1.0197,acosTest1.getAcos(30.0),0.001); + assertEquals(1.3953,acosTest1.getAcos(10.0),0.001); } + @Test + public void acospiTest(){ + MainApplication acospiTest1 = new MainApplication(); + assertEquals(Float.NaN,acospiTest1.getAcosPi(Math.PI),0.000001); + assertEquals(Float.NaN,acospiTest1.getAsinPi(Double.NEGATIVE_INFINITY),0.000001); + assertEquals(Float.NaN,acospiTest1.getAsinPi(Double.POSITIVE_INFINITY),0.000001); + } + @Test public void atanTest(){ MainApplication atanTest1 = new MainApplication(); assertEquals(0.0,atanTest1.getAtan(0.0), 0.01); + assertEquals(1.537,atanTest1.getAtan(30.0), 0.01); + assertEquals(1.5541,atanTest1.getAtan(60.0), 0.01); } From bd1eb013a33cc8bd2c136f58693e2c6ce2974f4d Mon Sep 17 00:00:00 2001 From: Kelly A Porter <78833247+KellyPorter02@users.noreply.github.com> Date: Sun, 28 Feb 2021 17:10:50 -0500 Subject: [PATCH 11/15] Kellybranch (#11) * Added sign inversion function * Added invert sign, square, square root, exponent, inverse functions Co-authored-by: kelly Co-authored-by: xyuan04 <78838190+xyuan04@users.noreply.github.com> --- .../scientificcalculator/MainApplication.java | 63 +++++++++++++++++++ .../TestMainApplication.java | 48 ++++++++++++++ 2 files changed, 111 insertions(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 962148e9..b19a4752 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -458,6 +458,67 @@ public boolean isStartLoop() { return startLoop; } + + // ADVANCED FUNCTIONS + + // Invert sign + public double getSignInversion(double num1) + { + double newNum = num1 * -1; + System.out.println(newNum); + return newNum; + } + + // O as input exception + public double getSignInversion0(double num1) { + System.out.println(num1); + return 0.0; + } + + // Compute square + public double getSquare(double num1) + { + double newNum = num1 * num1; + System.out.println(newNum); + return newNum; + } + + // Square Root + public double getSquareRoot(double num1) + { + if (num1 >= 0) { + double newNum = Math.sqrt(num1); + System.out.println(newNum); + return newNum; + } else { + System.out.println("Invalid number"); + return num1; + } + + } + + // Exponentiation + public double getExponentiation(double num1, double num2) + { + double newNum = Math.pow(num1, num2); + System.out.println(newNum); + return newNum; + } + + // Inverse (1/x) + public double getInverse(double num1) + { + if (num1 != 0) { + double newNum = 1 / num1; + System.out.println(newNum); + return newNum; + } else { + System.out.println("Err"); + return num1; + } + + } + //'Rock,Paper,Scissors' game. public static void playGame() { boolean gameOn = true; @@ -556,5 +617,7 @@ public static void playGame() { } } + } + diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index b57c79a4..c0bab2f1 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -284,8 +284,56 @@ public void testStoredMemory() { assertEquals(6.0, addMemTest.recallMemoryValue(), 1e-15); } + @Test + public void testGetSignInversion() { + MainApplication getSignInversion1 = new MainApplication(); + assertEquals(-2.0, getSignInversion1.getSignInversion(2.0), 0.1); + assertEquals(25.0, getSignInversion1.getSignInversion(-25.0), 0.1); + assertEquals(-0.125, getSignInversion1.getSignInversion(0.125), 0.1); + } + + @Test + public void testGetSignInversion0() { + MainApplication getSignInversion0 = new MainApplication(); + assertEquals(0.0, getSignInversion0.getSignInversion0(0.0), 0.1); + } + @Test + public void testGetSquare() { + MainApplication getSquare1 = new MainApplication(); + assertEquals(4.0, getSquare1.getSquare(2.0), 0.1); + assertEquals(9.0, getSquare1.getSquare(-3.0), 0.1); + assertEquals(0.0625, getSquare1.getSquare(-0.25), 0.1); + assertEquals(0.0, getSquare1.getSquare(0.0), 0.1); + } + @Test + public void testGetSquareRoot() { + MainApplication getSquareRoot1 = new MainApplication(); + assertEquals(4.0, getSquareRoot1.getSquareRoot(16.0), 0.1); + assertEquals(0.0, getSquareRoot1.getSquareRoot(0.0), 0.1); + } + @Test + public void testGetExponentiation() { + MainApplication getExponentiation1 = new MainApplication(); + assertEquals(8.0, getExponentiation1.getExponentiation(2.0, 3.0), 0.1); + assertEquals(-8.0, getExponentiation1.getExponentiation(-2.0, 3.0), 0.1); + assertEquals(0.125, getExponentiation1.getExponentiation(2.0, -3.0), 0.1); + assertEquals(0.0, getExponentiation1.getExponentiation(0.0, 2.0), 0.1); + assertEquals(2.0, getExponentiation1.getExponentiation(4.0, 0.5), 0.1); + assertEquals(0.5, getExponentiation1.getExponentiation(4.0, -0.5), 0.1); + assertEquals(1.0, getExponentiation1.getExponentiation(1.0, 0.0), 0.1); + assertEquals(0.0, getExponentiation1.getExponentiation(0.0, 1.0), 0.1); + } + + @Test + public void testGetInverse() { + MainApplication getInverse1 = new MainApplication(); + assertEquals(0.25, getInverse1.getInverse(4.0), 0.1); + assertEquals(-0.25, getInverse1.getInverse(-4.0), 0.1); + assertEquals(0.0, getInverse1.getInverse(0.0), 0.1); + + } } From 0e13d1bab46a4788c5125acaeff3f9766e9e1d61 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Sun, 28 Feb 2021 17:26:34 -0500 Subject: [PATCH 12/15] Branch xiong (#12) * added display value Co-authored-by: xiong --- .../scientificcalculator/MainApplication.java | 29 +++++++++---------- .../TestMainApplication.java | 1 - 2 files changed, 13 insertions(+), 17 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index b19a4752..8b3a95a7 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -30,6 +30,8 @@ public static void main(String[] args) { Console.println("MEMORY FUNCTIONS: 23-Clear memory 24-Add value to memory 25-Recall memory"); Console.println("DISPLAY CHANGES: 26-Switch Display Mode 27-Choose Display Mode"); Console.println("99-EXIT CALCULATOR"); + Console.println("Current Display: " + displayValue); + Integer choice = Console.getIntegerInput("Enter the number of the operation you want to perform."); @@ -161,10 +163,10 @@ public static void main(String[] args) { public static double userInputDouble2 = 0; public static void clearDisplay(){ - displayValue = "0.0"; + currentValue = 0; + displayValue = String.valueOf(currentValue); } - //IM A BASIC B public static double findSum(double a, double b) { currentValue = a + b; @@ -189,7 +191,7 @@ public static double findQuotient(double a, double b) { currentValue = a / b; displayValue = String.valueOf(currentValue); } else displayValue = "Err"; - currentValue = a / b; + return currentValue; } @@ -198,6 +200,7 @@ public static double findRemainder(double a, double b) { displayValue = String.valueOf(currentValue); return currentValue; } + // MEMORY // public static Double acceptUserInput() @@ -210,7 +213,6 @@ public static double getMemoryValue() { public static double setCurrentValue(double input) { currentValue = input; displayValue = String.valueOf(currentValue); - //System.out.println(currentValue); return currentValue; } @@ -223,7 +225,6 @@ public static double returnCurrentValue() { // M+ KEY: Recall current value from memory to the display public static double recallMemoryValue() { displayValue = String.valueOf(memoryValue); - System.out.println(memoryValue); return memoryValue; } @@ -231,7 +232,6 @@ public static double recallMemoryValue() { public static double clearMemory() { memoryValue = 0.0; displayValue = String.valueOf(memoryValue); - System.out.println(memoryValue); return memoryValue; } @@ -241,7 +241,6 @@ public static double addCurrentValueToMemory() { memoryValue = currentValue; currentValue = 0.0; displayValue = String.valueOf(currentValue); - System.out.println(currentValue); return currentValue; } @@ -272,7 +271,6 @@ public static double findFactorial(double userInput) { public static double logarithm(double num1) { double newNum = Math.log10(num1); displayValue = String.valueOf(newNum); - System.out.println(newNum); return newNum; } @@ -282,7 +280,6 @@ public static double logarithm(double num1) { public static double invLog(double num1) { double newNum = Math.pow(10,num1); displayValue = String.valueOf(newNum); - System.out.println(newNum); return newNum; } @@ -290,7 +287,6 @@ public static double invLog(double num1) { public static double natLog(double num1) { double newNum = Math.log(num1); displayValue = String.valueOf(newNum); - System.out.println(newNum); return newNum; } //Inverted Natural Logs @@ -299,7 +295,6 @@ public static double natLog(double num1) { public static double invNatLog(double num1) { double newNum = Math.pow(Math.E,num1); displayValue = String.valueOf(newNum); - System.out.println(newNum); return newNum; } @@ -401,13 +396,16 @@ public static double getSin (double a) { displayValue = String.valueOf(currentValue); return currentValue; } - + + + public static double getSinPi (double a) { //double b=Math.toRadians(a); System.out.println(Math.sin(a)); return (Math.sin(a)); } + public static double getCos(double a) { double b=Math.toRadians(a); currentValue = (Math.cos(b)); @@ -415,12 +413,14 @@ public static double getCos(double a) { return currentValue; } + public static double getCosPi (double a) { //double b=Math.toRadians(a); System.out.println(Math.cos(a)); return (Math.cos(a)); } + public static double getTan(double a) { double b=Math.toRadians(a); currentValue = (Math.tan(b)); @@ -452,10 +452,6 @@ public static double getAtan (double a){ currentValue = (Math.atan(a)); displayValue = String.valueOf(currentValue); return currentValue; - - - public boolean isStartLoop() { - return startLoop; } @@ -618,6 +614,7 @@ public static void playGame() { } + } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index c0bab2f1..2c30f2c1 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -100,7 +100,6 @@ public void getInvNatLog0() { assertEquals(0.904837418, newLog.invNatLog(-0.1), 0.0000001); } - } @Test //Log base 10 method test From a5d173e3a1d00bab64ee963b667739c1c4208a10 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Sun, 28 Feb 2021 21:45:10 -0500 Subject: [PATCH 13/15] Branch xiong (#13) added getTime feature/cleaned up code. Removed test class (newCalculator). Finalizing project. Created uml diagram for MainApplication and TestMainApplication. Co-authored-by: xiong --- MainApplication.uml | 22 ++ TestMainApplication.uml | 22 ++ pom.xml | 12 ++ .../scientificcalculator/MainApplication.java | 197 ++++++++++-------- .../scientificcalculator/NewCalculator.java | 11 - .../TestMainApplication.java | 12 +- 6 files changed, 174 insertions(+), 102 deletions(-) create mode 100644 MainApplication.uml create mode 100644 TestMainApplication.uml delete mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java diff --git a/MainApplication.uml b/MainApplication.uml new file mode 100644 index 00000000..90aa2f50 --- /dev/null +++ b/MainApplication.uml @@ -0,0 +1,22 @@ + + + JAVA + com.zipcodewilmington.scientificcalculator.MainApplication + + com.zipcodewilmington.scientificcalculator.MainApplication + + + + + + com.zipcodewilmington.scientificcalculator.MainApplication + + + Fields + Constructors + Methods + + All + private + + diff --git a/TestMainApplication.uml b/TestMainApplication.uml new file mode 100644 index 00000000..cbb4a407 --- /dev/null +++ b/TestMainApplication.uml @@ -0,0 +1,22 @@ + + + JAVA + com.zipcodewilmington.scientific_calculator.TestMainApplication + + com.zipcodewilmington.scientific_calculator.TestMainApplication + + + + + + com.zipcodewilmington.scientific_calculator.TestMainApplication + + + Fields + Constructors + Methods + + All + private + + diff --git a/pom.xml b/pom.xml index 4cf506b5..d1c9be3d 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,18 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 8 + 8 + + + + junit diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 8b3a95a7..b479336b 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,6 +1,8 @@ package com.zipcodewilmington.scientificcalculator; import com.sun.codemodel.internal.JWhileLoop; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; /** * Created by leon on 2/9/18. @@ -16,21 +18,31 @@ public class MainApplication { public static void main(String[] args) { - Console.println("Welcome to my calculator!"); - Console.println("What operation would you like to perform?"); + Console.println("HI! I'M CODEB0T0VER9000!"); + Console.println("I SEE YOU NEED HELP WITH YOUR MATH FRIEND, HOW MAY I BE OF SERVICE?"); while (startLoop) { - Console.println("SYSTEM OPERATIONS: 0-Clear Display"); - Console.println("ARITHMETIC OPERATIONS: 1-Add 2-Subtract 3-Multiple 4-Divide"); - Console.println("ADVANCED OPERATIONS: 5-Square 6-Square Root 7-Exponentiation 8-Inverse 9-Change Sign 10-Factorial"); - Console.println("TRIG FUNCTIONS: 11-Sine 12-Cosine 13-Tangent"); - Console.println("INVERSE TRIG FUNCTIONS: 14-Inverse Sine 15-Inverse Cosine 16-Inverse Tangent"); - Console.println("SWITCH TRIG UNITS: 17-Switch Trig Units 18-Select Trig Units"); - Console.println("LOGARITHMIC FUNCTIONS: 19-Log 20-Inverse Log 21-Natural Log 22-Inverse Natural Log"); - Console.println("MEMORY FUNCTIONS: 23-Clear memory 24-Add value to memory 25-Recall memory"); - Console.println("DISPLAY CHANGES: 26-Switch Display Mode 27-Choose Display Mode"); + while (displayValue.equals("Err") ) { + userInputDouble = Console.getDoubleInput("Please press 0 to continue"); + if (userInputDouble == 0) { + clearDisplay(); + } + + } + Console.println("0-Clear Display"); + Console.println("1-Add 2-Subtract 3-Multiple 4-Divide"); + Console.println("5-Square 6-Square Root 7-Exponentiation 8-Inverse 9-Change Sign 10-Factorial"); + Console.println("11-Sine 12-Cosine 13-Tangent"); + Console.println("14-Inverse Sine 15-Inverse Cosine 16-Inverse Tangent"); + Console.println("17-Switch Trig Units 18-Select Trig Units"); + Console.println("19-Log 20-Inverse Log 21-Natural Log 22-Inverse Natural Log"); + Console.println("23-Clear memory 24-Add value to memory 25-Recall memory"); + Console.println("26-Switch Display Mode 27-Choose Display Mode"); + Console.println("28-Show Current Time"); Console.println("99-EXIT CALCULATOR"); - Console.println("Current Display: " + displayValue); + Console.println(""); + Console.println("CURRENT DISPLAY: " + displayValue); + Console.println(""); Integer choice = Console.getIntegerInput("Enter the number of the operation you want to perform."); @@ -39,6 +51,7 @@ public static void main(String[] args) { case 0: clearDisplay(); System.out.println(displayValue); + break; case 1: userInputDouble = Console.getDoubleInput("Enter first number"); userInputDouble2 = Console.getDoubleInput("Enter second number"); @@ -63,6 +76,32 @@ public static void main(String[] args) { findQuotient(userInputDouble, userInputDouble2); System.out.println(displayValue); break; + case 5: + userInputDouble = Console.getDoubleInput("Enter a number"); + getSquare(userInputDouble); + System.out.println(displayValue); + break; + case 6: + userInputDouble = Console.getDoubleInput("Enter a number"); + getSquareRoot(userInputDouble); + System.out.println(displayValue); + break; + case 7: + userInputDouble = Console.getDoubleInput("Enter first number"); + userInputDouble2 = Console.getDoubleInput("Enter second number"); + getExponentiation(userInputDouble, userInputDouble2); + System.out.println(displayValue); + break; + case 8: + userInputDouble = Console.getDoubleInput("Enter a number"); + getInverse(userInputDouble); + System.out.println(displayValue); + break; + case 9: + userInputDouble = Console.getDoubleInput("Enter a number"); + getSignInversion(userInputDouble); + System.out.println(displayValue); + break; case 10: userInputDouble = Console.getDoubleInput("Enter a number"); findFactorial(userInputDouble); @@ -140,6 +179,10 @@ public static void main(String[] args) { String mode = Console.getStringInput("Enter the desired mode"); switchDisplayMode(mode); break; + case 28: + getTime(); + System.out.println(displayValue); + break; case 98: userInputDouble = Console.getDoubleInput("Enter a number as a double"); setCurrentValue(userInputDouble); @@ -258,7 +301,6 @@ public static double findFactorial(double userInput) { setCurrentValue(userInput); displayValue = String.valueOf(currentValue); - System.out.println(currentValue); return currentValue; } @@ -269,33 +311,33 @@ public static double findFactorial(double userInput) { //Takes a value for num2 for the log equation. num1 is not used in this case public static double logarithm(double num1) { - double newNum = Math.log10(num1); - displayValue = String.valueOf(newNum); - return newNum; + currentValue = Math.log10(num1); + displayValue = String.valueOf(currentValue); + return currentValue; } //Inverted Logs public static double invLog(double num1) { - double newNum = Math.pow(10,num1); - displayValue = String.valueOf(newNum); - return newNum; + currentValue = Math.pow(10,num1); + displayValue = String.valueOf(currentValue); + return currentValue; } //Natural Logs public static double natLog(double num1) { - double newNum = Math.log(num1); - displayValue = String.valueOf(newNum); - return newNum; + currentValue = Math.log(num1); + displayValue = String.valueOf(currentValue); + return currentValue; } //Inverted Natural Logs public static double invNatLog(double num1) { - double newNum = Math.pow(Math.E,num1); - displayValue = String.valueOf(newNum); - return newNum; + currentValue = Math.pow(Math.E,num1); + displayValue = String.valueOf(currentValue); + return currentValue; } @@ -304,7 +346,6 @@ public static double invNatLog(double num1) { public static void getMode() { displayValue = String.valueOf(currentMode); - System.out.println(currentMode); } //public void setMode(String newMode){currentMode = newMode;} @@ -313,22 +354,17 @@ public static String switchDisplayMode() { if (currentMode.equals("binary")) { currentMode = "octal"; displayValue = currentMode; - System.out.println("octal"); } else if (currentMode.equals("octal")) { currentMode = "decimal"; displayValue = currentMode; - System.out.println("decimal"); } else if (currentMode.equals("decimal")) { currentMode = "hexadecimal"; displayValue = currentMode; - System.out.println("hexadecimal"); } else if (currentMode.equals("hexadecimal")) { currentMode = "binary"; displayValue = currentMode; - System.out.println("binary"); } else displayValue = "Err"; - System.out.println("Err"); return currentMode; } @@ -349,14 +385,14 @@ public static String switchDisplayMode(String mode) { displayValue = currentMode; } else mode = "Err"; displayValue = mode; - System.out.println(mode); + System.out.println("Err"); return mode; } //UNIT CHANGES public static void getUnit() { - displayValue = currentMode; + displayValue = currentUnit; System.out.println(currentUnit); } @@ -364,15 +400,11 @@ public static String switchUnitsMode() { if (currentUnit.equals("degrees")) { currentUnit = "radians"; displayValue = currentUnit; - System.out.println("radians"); } else if (currentUnit.equals("radians")) { currentUnit = "degrees"; displayValue = currentUnit; - System.out.println("degrees"); } else - System.out.println("Err"); displayValue = "Err"; - return currentUnit; } @@ -385,7 +417,7 @@ public static String switchUnitsMode(String mode) { displayValue = currentUnit; } else mode = "Err"; displayValue = mode; - System.out.println(mode); + System.out.println("Err"); return mode; } // TRIG FUNCTIONS @@ -398,7 +430,6 @@ public static double getSin (double a) { } - public static double getSinPi (double a) { //double b=Math.toRadians(a); System.out.println(Math.sin(a)); @@ -434,6 +465,12 @@ public static double getAsinPi(double a) { return currentValue; } + public static double getAcosPi(double a) { + currentValue = (Math.acos(a)); + displayValue = String.valueOf(currentValue); + return currentValue; + } + public static double getAsin(double a) { double b=Math.toRadians(a); currentValue = (Math.asin(b)); @@ -458,72 +495,59 @@ public static double getAtan (double a){ // ADVANCED FUNCTIONS // Invert sign - public double getSignInversion(double num1) - { - double newNum = num1 * -1; - System.out.println(newNum); - return newNum; + public static double getSignInversion(double num1) { + if (num1 != 0) { + currentValue = num1 * -1; + displayValue = String.valueOf(currentValue); + } else currentValue = 0; + displayValue = String.valueOf(currentValue); + return currentValue; } - // O as input exception - public double getSignInversion0(double num1) { - System.out.println(num1); - return 0.0; - } // Compute square - public double getSquare(double num1) - { - double newNum = num1 * num1; - System.out.println(newNum); - return newNum; + public static double getSquare(double num1) { + currentValue = num1 * num1; + displayValue = String.valueOf(currentValue); + return currentValue; } // Square Root - public double getSquareRoot(double num1) - { + public static double getSquareRoot(double num1) { if (num1 >= 0) { - double newNum = Math.sqrt(num1); - System.out.println(newNum); - return newNum; - } else { - System.out.println("Invalid number"); - return num1; - } - + currentValue = Math.sqrt(num1); + displayValue = String.valueOf(currentValue); + } else displayValue = "Err"; + return currentValue; } // Exponentiation - public double getExponentiation(double num1, double num2) - { - double newNum = Math.pow(num1, num2); - System.out.println(newNum); - return newNum; + public static double getExponentiation(double num1, double num2) { + currentValue = Math.pow(num1, num2); + displayValue = String.valueOf(currentValue); + return currentValue; } // Inverse (1/x) - public double getInverse(double num1) - { + public static double getInverse(double num1) { if (num1 != 0) { - double newNum = 1 / num1; - System.out.println(newNum); - return newNum; - } else { - System.out.println("Err"); - return num1; - } + currentValue = 1 / num1; + displayValue = String.valueOf(currentValue); + } else displayValue = "Err"; + return currentValue; } //'Rock,Paper,Scissors' game. + //No unit test but tested and debugged live in production. public static void playGame() { boolean gameOn = true; - double userChoice = 0; - double continueGame = 0; + double userChoice; + double continueGame; double score = 0; double gamesPlayed = 0; - String computerMove = ""; - String userMove = ""; + String computerMove; + String userMove; @@ -553,7 +577,6 @@ public static void playGame() { } else { System.out.println("Invalid, choose 0,1,2"); continue; } - //System.out.println(computerDub); System.out.println("You play: " + userMove); System.out.println("I play: " + computerMove); @@ -604,6 +627,7 @@ public static void playGame() { gameOn = true; break; } else if (continueGame == 2) { + System.out.println("Goodbye!"); gameOn = false; break; } else System.out.println("Invalid selection: Please choose 1 - Yes or 2 - No"); @@ -614,6 +638,13 @@ public static void playGame() { } + //Time display + public static void getTime(){ + DateTimeFormatter timeFormat = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"); + LocalDateTime now = LocalDateTime.now(); + displayValue = (timeFormat.format(now)); + } + } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java deleted file mode 100644 index b0a77485..00000000 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/NewCalculator.java +++ /dev/null @@ -1,11 +0,0 @@ -package com.zipcodewilmington.scientificcalculator; - -public class NewCalculator { - static MainApplication calculator = new MainApplication(); - - public static void main(String[] args) { - calculator.playGame(); - - } - -} diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 2c30f2c1..288419b6 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -288,14 +288,9 @@ public void testGetSignInversion() { MainApplication getSignInversion1 = new MainApplication(); assertEquals(-2.0, getSignInversion1.getSignInversion(2.0), 0.1); assertEquals(25.0, getSignInversion1.getSignInversion(-25.0), 0.1); - assertEquals(-0.125, getSignInversion1.getSignInversion(0.125), 0.1); + assertEquals(0, getSignInversion1.getSignInversion(0), 0.1); } - @Test - public void testGetSignInversion0() { - MainApplication getSignInversion0 = new MainApplication(); - assertEquals(0.0, getSignInversion0.getSignInversion0(0.0), 0.1); - } @Test public void testGetSquare() { @@ -326,13 +321,14 @@ public void testGetExponentiation() { assertEquals(0.0, getExponentiation1.getExponentiation(0.0, 1.0), 0.1); } - @Test + @Test public void testGetInverse() { MainApplication getInverse1 = new MainApplication(); assertEquals(0.25, getInverse1.getInverse(4.0), 0.1); assertEquals(-0.25, getInverse1.getInverse(-4.0), 0.1); - assertEquals(0.0, getInverse1.getInverse(0.0), 0.1); + assertEquals(.01, getInverse1.getInverse(100), 0.1); } + } From ae773927525bac6d8834796b6c8fc6bf24d89f18 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Sun, 28 Feb 2021 22:09:18 -0500 Subject: [PATCH 14/15] removed case 98 in loop (#14) Co-authored-by: xiong --- MainApplication.uml | 2 +- TestMainApplication.uml | 4 ++-- .../scientificcalculator/MainApplication.java | 4 ---- 3 files changed, 3 insertions(+), 7 deletions(-) diff --git a/MainApplication.uml b/MainApplication.uml index 90aa2f50..2358e9ad 100644 --- a/MainApplication.uml +++ b/MainApplication.uml @@ -7,7 +7,7 @@ - + com.zipcodewilmington.scientificcalculator.MainApplication diff --git a/TestMainApplication.uml b/TestMainApplication.uml index cbb4a407..8e495989 100644 --- a/TestMainApplication.uml +++ b/TestMainApplication.uml @@ -3,11 +3,11 @@ JAVA com.zipcodewilmington.scientific_calculator.TestMainApplication - com.zipcodewilmington.scientific_calculator.TestMainApplication + com.zipcodewilmington.scientific_calculator.TestMainApplication - + com.zipcodewilmington.scientific_calculator.TestMainApplication diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index b479336b..ae164685 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -183,10 +183,6 @@ public static void main(String[] args) { getTime(); System.out.println(displayValue); break; - case 98: - userInputDouble = Console.getDoubleInput("Enter a number as a double"); - setCurrentValue(userInputDouble); - break; case 99: startLoop = false; System.out.println("Goodbye"); From e40d8f9e6f99b92d447c77844d39dbfeb884633b Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Mon, 1 Mar 2021 11:35:58 -0500 Subject: [PATCH 15/15] Branch xiong (#15) added runCalculator() to actually start up the program and updated uml diagram. Co-authored-by: xiong --- MainApplication.uml | 4 +- .../scientificcalculator/MainApplication.java | 41 ++++++++++--------- 2 files changed, 24 insertions(+), 21 deletions(-) diff --git a/MainApplication.uml b/MainApplication.uml index 2358e9ad..9200f767 100644 --- a/MainApplication.uml +++ b/MainApplication.uml @@ -3,11 +3,11 @@ JAVA com.zipcodewilmington.scientificcalculator.MainApplication - com.zipcodewilmington.scientificcalculator.MainApplication + com.zipcodewilmington.scientificcalculator.MainApplication - + com.zipcodewilmington.scientificcalculator.MainApplication diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index ae164685..db881f0f 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -18,11 +18,14 @@ public class MainApplication { public static void main(String[] args) { + } + + public static void runCalculator() { Console.println("HI! I'M CODEB0T0VER9000!"); Console.println("I SEE YOU NEED HELP WITH YOUR MATH FRIEND, HOW MAY I BE OF SERVICE?"); while (startLoop) { - while (displayValue.equals("Err") ) { + while (displayValue.equals("Err")) { userInputDouble = Console.getDoubleInput("Please press 0 to continue"); if (userInputDouble == 0) { clearDisplay(); @@ -58,24 +61,24 @@ public static void main(String[] args) { findSum(userInputDouble, userInputDouble2); System.out.println(displayValue); break; - case 2: - userInputDouble = Console.getDoubleInput("Enter first number"); - userInputDouble2 = Console.getDoubleInput("Enter second number"); - findDifference(userInputDouble, userInputDouble2); - System.out.println(displayValue); - break; - case 3: - userInputDouble = Console.getDoubleInput("Enter first number"); - userInputDouble2 = Console.getDoubleInput("Enter second number"); - findProduct(userInputDouble, userInputDouble2); - System.out.println(displayValue); - break; - case 4: - userInputDouble = Console.getDoubleInput("Enter first number"); - userInputDouble2 = Console.getDoubleInput("Enter second number"); - findQuotient(userInputDouble, userInputDouble2); - System.out.println(displayValue); - break; + case 2: + userInputDouble = Console.getDoubleInput("Enter first number"); + userInputDouble2 = Console.getDoubleInput("Enter second number"); + findDifference(userInputDouble, userInputDouble2); + System.out.println(displayValue); + break; + case 3: + userInputDouble = Console.getDoubleInput("Enter first number"); + userInputDouble2 = Console.getDoubleInput("Enter second number"); + findProduct(userInputDouble, userInputDouble2); + System.out.println(displayValue); + break; + case 4: + userInputDouble = Console.getDoubleInput("Enter first number"); + userInputDouble2 = Console.getDoubleInput("Enter second number"); + findQuotient(userInputDouble, userInputDouble2); + System.out.println(displayValue); + break; case 5: userInputDouble = Console.getDoubleInput("Enter a number"); getSquare(userInputDouble);