From ebadd7c83d35372223e0029c49f5f4e1e9022f2a Mon Sep 17 00:00:00 2001 From: Fitru Date: Fri, 24 Jun 2022 18:11:16 -0400 Subject: [PATCH 01/46] add --- README.md | 1 + src/.idea/.gitignore | 3 +++ src/.idea/misc.xml | 6 ++++++ src/.idea/modules.xml | 10 ++++++++++ src/.idea/vcs.xml | 6 ++++++ .../scientificcalculator/MainApplication.java | 1 + 6 files changed, 27 insertions(+) create mode 100644 src/.idea/.gitignore create mode 100644 src/.idea/misc.xml create mode 100644 src/.idea/modules.xml create mode 100644 src/.idea/vcs.xml diff --git a/README.md b/README.md index 40cc253..2d815ea 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,4 @@ +Dan # ScientificCalculator (maven) ZCW diff --git a/src/.idea/.gitignore b/src/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/src/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/src/.idea/misc.xml b/src/.idea/misc.xml new file mode 100644 index 0000000..e3a9e45 --- /dev/null +++ b/src/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/src/.idea/modules.xml b/src/.idea/modules.xml new file mode 100644 index 0000000..31eaf94 --- /dev/null +++ b/src/.idea/modules.xml @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/src/.idea/vcs.xml b/src/.idea/vcs.xml new file mode 100644 index 0000000..6c0b863 --- /dev/null +++ b/src/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f42132..68c1369 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -14,4 +14,5 @@ public static void main(String[] args) { Console.println("The user input %s as a integer", i); Console.println("The user input %s as a d", d); } + } From 544b39af370f9ba6016d596120c368d7e1fee209 Mon Sep 17 00:00:00 2001 From: Thina Date: Sat, 25 Jun 2022 09:13:19 -0400 Subject: [PATCH 02/46] scientific features --- .DS_Store | Bin 0 -> 6148 bytes 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 .../ScientificFeatures.java | 94 ++++++++++++++++++ 7 files changed, 94 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/ScientificFeatures.java diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..da23850804c380aefa471bf2829a2f90da11e9af GIT binary patch literal 6148 zcmeHK%SyvQ6rE|SO({Ya3SADkE!dZ$xCycTfDv7&)Wj4G#!N|CvnYkE^@sctzsGxL zCSWmZ5qmGpoco-~9LPKvW87VYea39Ym<0`yqf#O0t_;;oG9t$@vRM$z0IZK-W@3LG z@Z0MwV<~$G^6%dtN7=mB`{cEHV{5xEyt+k{yF3yn|v^^XjEZER#p@l-Xq#Au&J<5Cg=(W;0;U z1*^T;G|=ja0b-zn0o)%1G(^W>p;2ue(BbtN;|)X<(D5ySC=5CV3ylx~;kp!1mvZyO z;JO_A!sIyy3yr#*aWylHV`eTNFI>$IexcGCcQjH@3=jkB4Aix0S5T0$LrihS(LXQhx3)Wv0FQMuS7}0}DO-RvTnk`Lg4yBN@zK~Di^Ek7+ zEo$vmL}y_3+nt?Bm@i>x2LME86mJ7~0N|n$)*3i`BeYLCCpBwv5CuIWD)T{O zrt>hmOnPP4TR%}*5hhu0r~{I?hb}i)NfxWJqefYr>)60-xDB__^_t`H?%qL5?i}t< zT5^1}({9PV?cK?w;cjeh9iMj}(|)F&4T%E(H!W)xr|^Q4Sw2s}FiTZ-k2dmmpnx9a zQ2d!ZZ9ZS}oN~d)3@`)Cz#<0h8S1Vsa$q|%zzqCb2Izc{sD!@7%Ah_vaL_FPB3&c3 z;GB91ijfw5ihNU4t`*UWB>pF literal 0 HcmV?d00001 diff --git a/src/main/.DS_Store b/src/main/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..cef2a3054957ff9008599d752e8fdca5c0ef0a29 GIT binary patch literal 6148 zcmeHK%SyvQ6rHirrW7Fyg)Rr&7VJw=+=N39+}T(%>VlR!8nf6tkrtw8x?DFt7=#6x_#?C$lS~PY?}7{$u(LRQpQ24`@v;2 z%7@O*sZ26IN=6e^5QQU1xw(pxQ09F(O~O>wdOBd&?Ap+2%;(+SVN-OD4i-%@Kkl@e zqSx*&7Bzc!Z~x?c_!K`U@+4Gat(+Jj27X`w_XhzD(KT3TR9gphczwpWg@^(=z9kTaLDyiR5h5U5mjdci zZk`ximxEuJJl9~MQI|8WW`=Rh%;n>StJ%RXR666XM(T+HVqlqpiZ&fQ|Igr;S^3Cc zE+LB;AO`*!1Kb*TgFY_z|dG+Q=ER!ejl-Xq#Au&J<5Cg=(W;0;U z1*^5$G|=ja0b-zn0o)%1G(^W>p;2ue(BbtN<8?$7(D5ySC=5CV3ylx~;kp!1mvZyO z;JO_A!sIyy3yr#*aWylHV`eTNFI>$IexcGCcQjH@3=jkB4Ait~2%C84;& m;(H1jrW9i=mEtv2Bj}f8Ao>mqi|9e&9|1!HH_X7FGVlha@l*Ez 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..bb7ffc3751e1f268bf341d7b051f9318fefe6e97 GIT binary patch literal 6148 zcmeHKQA@)x5WZ|vTSVA{!X5*@4xDa^;!BzO2dwCW%53e_Vr^vY+`}03S^to~#NXpx zl8R#rz9=epaQQBmyJYz?at#28?l4*hr~`n5N?38R`9Nr#bVe%HLn!ndDdZ5t73$?o zG&_DH19W!Fkl}g7(1-WucL@O`=pSMm;JGRogrn>}OjL+D&*6O%XL+mjA}ZC|-28&G z;4C`l{*4;>d5{mYZZJ5d-jPyCSlU5&9QQ}P`tqJi^B_+91Dy~@eGEA}iPK1px@wq4 zna=gifa5xDuihAs+nueZ+}PfnH05|_qt%q1_4Z`qIxDMdyNA8oNM=eVh zOL#)#%lm!s2Wg_xYs@L^?=)xeFK>c>J2SuxdFAd>&a+q;H0dDp$~cc*S=bkf z(5s_g>TnRAL2j7=W?-6us_E9L{vUk){+~|b9y7oU{3`}TZQtMT;+AY}o!K1KT8Vmr qN= 0) { + for (int i = 1; i <= num1; i++) { + result = result * 1; + } + } + + return result; + } + public double log(double num1){ + result = Math.log10(num1); + return result; + + } + + public double inverseLog(double num1){ + result = Math.pow(10, num1); + return result; + } + + public double ln(double num1){ + result = Math.log10(num1); + return result; + } + + public double inverseLn(double num1){ + result = Math.pow(Math.E, num1); + return result; + } + + +} From 6afa1d570fb2924b7b7a0ca3610290b8ce51f541 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sat, 25 Jun 2022 11:19:31 -0400 Subject: [PATCH 03/46] Added TestScientificFeatures --- src/.idea/uiDesigner.xml | 124 ++++++++++++++++++ .../TestScientificFeatures.java | 72 ++++++++++ .../scientificcalculator/Console.class | Bin 0 -> 1811 bytes .../MainApplication.class | Bin 0 -> 1194 bytes .../ScientificFeatures.class | Bin 0 -> 2418 bytes .../ScientificFeaturesTest.class | Bin 0 -> 828 bytes 6 files changed, 196 insertions(+) create mode 100644 src/.idea/uiDesigner.xml create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.java create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class diff --git a/src/.idea/uiDesigner.xml b/src/.idea/uiDesigner.xml new file mode 100644 index 0000000..2b63946 --- /dev/null +++ b/src/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.java new file mode 100644 index 0000000..e5047c5 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.java @@ -0,0 +1,72 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class TestScientificFeatures extends ScientificFeatures { + + @Test + void testSquare() { + ScientificFeatures PaydayTest = new ScientificFeatures(); + double something = PaydayTest.square(5); + Assertions.assertEquals(25.0, something); + } + + @Test + void testSquareRoot() { + } + + @Test + void testSwitchSign() { + } + + @Test + void testInverse() { + } + + @Test + void testSine() { + } + + @Test + void testCos() { + } + + @Test + void testTan() { + } + + @Test + void testInverseSine() { + } + + @Test + void testInverseCosine() { + } + + @Test + void testInverseTangent() { + } + + @Test + void testFactorial() { + } + + @Test + void testLog() { + } + + @Test + void testInverseLog() { + } + + @Test + void testLn() { + } + + @Test + void testInverseLn() { + } +} \ No newline at end of file diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class new file mode 100644 index 0000000000000000000000000000000000000000..1b66f5821543365e55f466fe7eef909f33bfce8b GIT binary patch literal 1811 zcmb7F?Q+vb6g_JvQLLyqr_1`=YH?z|CE0_GlCvu1w5ux+F!;SIp{S9!DJ<^Kcv|7|sQ{@BbkOf!-AlW!NWS zMk_xKq)7NaB5LvWaxJTu9S%E4xIGx z89ryINL93YQw@@#)eBg%n|g|2K2J%zQG_gS+q%wpXxO5hR9~oEETHLO1*;6>O8jm* zQjz?bMu{&BBW?14p>9Dplm3o~?(iL3?o>yU3)?)BcAhVem_13ZU+DaQ16$M>)LB%Z z&`M1k0l)>bd?r?b`pI)Ce0o7hBruqDi% z-i_;HXuG(MA02Gi?*EBlX=s*I5A?q9GbgeGvB3js(*uS-i>2hijPwRqyP=4eI$G~1 zgVu-U7gpX2ymK%RCGe6RDteYvw0RhIr4g-hY*ME)mx|xC2cRADI2N&k4#TMrYAciM z;3mW3$Dz~`S$%Y}=IKtfpE1y}O`l)V%%>Tn_h|Du*b^F5a5e{l&ZJLcF9YB!d`+`Q z_O_rE8@!HcO6op^(_DFmPwoyG>=g{UPiqu!S>`e%&fz@G02deV4e>m(2Q}ww6DEyn zzQi=J@&ZTxNm!@A$pYcTJHm;au!e6bStf9o1Xd~8vA?kJ>r;IC9A9*r)xS}BfzzaS zd297C{hF0Lg%KK0ljIqC&XQkqX`YiA1HMazPoR#AxJ3Nc&&#w{p%PnI%QLRh+xl5y zLuTtZX(*Uk$=PbSLVs78)_;#&EQze*TB`he{6Oz<;#jBe4g5?qmqx!}3%79eEd>>^ Ax&QzG literal 0 HcmV?d00001 diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class new file mode 100644 index 0000000000000000000000000000000000000000..fc066c749c8c888e4c6ad415e30abed9cc1edb0f GIT binary patch literal 1194 zcmbVMT~8B16g|@xx-BcM3q=sYEedQ4w2Jse35ixsND4lb)EJ+(+p!GU&NkbvM*on{ zKG~S)5Aa7B?{t^6D#VY?W+wNZd(S;{=k9*{{`o6_ee9+YLp+IujtNXMWKZokcG@&ozLPLYbu<(Mrj@RL4;F+CwrenKK-?anJ&!>^bR1&(5OPFTZ zrl|6J(RI8Qe=FRMknO;e<(?zB48&{Uj8e;0Pxd^QGbFpdkbx^1EUPw>QxC}9uDlv^ zg$gT5RhD7;sSLPp+GcMUsiYV>W-v=on+IY3f$a9_Ol#*b7si;QVjAYCB@wSQNfvK& zUop??Sin_=3^5;s?udH*57bd~MZ+~pKhxau`c0RY6!o%>>o7ynPloQl6deW=@e0Gz z@d-EkJ?e*0CpK4mrcH0u8x1!ZmM;j2PN`vyVg7=cRuUG&?mt}bp)KU2Zr2r#9SDyu zH&Labpbpf8c{COc+ZW1?oQdE>^cePP|6j5~H9Mq&Va^(#qUf#* z4Z>}|O;u*jff*Pf#_uyifS{By;OvG8Y5klM-4H{%?)80#KNIS}v%mDFq=p`Otkb8d zo*0<=IB6}ARi>TMK2iJx_HhUoX;rXVH)z$v0BmB5tQ1PaB$fPuh!V6{jb!`_Vgsa% z%m9~bMs9#BhsNRnOGidNLD0+iMqR--LSu7itcJ#xGDf9Wpb@1;g;L1S0Ov4;Mfw3) un8sc5JVtgXs~DEXE!?K~40f=MJ0vwn0(U4fMp+i_;XdNzeLyiWJp2LYD>7dI literal 0 HcmV?d00001 diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class new file mode 100644 index 0000000000000000000000000000000000000000..c83700d0dd248d93dcf2820188428e1868569f67 GIT binary patch literal 2418 zcmbu9-%}e^6vw|y0vpmzNPz-YXk(-XRwZCtZK3=s6rqNKgi@*cuq;csZP=yB2Btnc zI?%(2r&yJ&h?`ByS&5AQ7lbb!~-upS{p7Xu?)9*k02w)2D zC((kKinxYWv?<8kGY*VG#jwkTm92Z0=_+WuCT!tODToaXZ?q$Ub`?ntr=TgAG@ZS| z2V&oJwyi@^*%Nlzb?idT6qfCZ9buYA#jIBh*Qpjtfpft!+{p=fOIpQdfT2bNuX4n*5EH{2@=SvoF31D5yUv=iEeyLRy?G5o(i^J@TiUvYmp$8b zy!lr(jCi(dc=Mwg#-trL{0$d1TxvM{9j|M6qv7C|1g@~+>+mp3J;hMW8QD%!&VINr48keR@u3_F^HujH_VNK~i%`{?ei}TBJPMk34)%mYjOkv=)RcPVYZ&#fX#|RhQt+ z1Qh;w)i`GO%sa~Q2CV}BTrn_HYmQo>9@u?ECmVivje9V&;OFIX~tKcf`@s7iYm&gXoKXkutJKFFwUf z5p_Dxj%P#sOu)|sXX4w!Z|2{r!x7X$QZJl9e~VJm`n;0$Pvn< z5JEPS$y#&dYZ1tcL|!@pS!#~F9D%$-jCl$iYQJ|jO!ib<VWMGoSDHea4(ww0jXW88AtlKOuQ?~N{ zXDPRH6zy$ncz1I=kkNQZrb)zleuJv~N{)g%LB_{gH6BrfC8l!ogd)5XAQ%1Hm(ja1 z$ty4&L0#doRzuWg`rizw|0&URCVD%BY^JHZ0WzHE+`lBc$wcplsLc|6mz`+Adw&Ai Cl6YAF literal 0 HcmV?d00001 diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class new file mode 100644 index 0000000000000000000000000000000000000000..b19ec810423f8ff62c5724d17327ea02e1ea2006 GIT binary patch literal 828 zcmbtSU2oGs5S(+;qzx_&X@Hg%2p^S_BH?EQltwj`kSv5q6{(LG_Xt_T z5J>z0eiUNP4e$VOIZJ!q-Pzf>z5DU=>vsTq*lEE-t%wG zg*!hMXjv*4&8O6QCC^Xf`Gu%wi}90tr7)?Y*la2wLV?ZKCGRy=V_j$-XP9Ni%K3n| zqyJxm)8b@~Oqs{(P`jyY{reak?BS_=C(*-IJ^;6zeH)vfN zSjHx;e*wS^Y|#U@nf0pT3F`cSjc@RdSsy*glJMsMO4`?ZO@P0=3iFz?jd Date: Sat, 25 Jun 2022 11:29:57 -0400 Subject: [PATCH 04/46] Changed the file location of ScientificFeaturesTest --- .../TestScientificFeatures.java | 72 ------------------ .../ScientificFeaturesTest.class | Bin 828 -> 0 bytes .../TestScientificFeatures.class | Bin 0 -> 2220 bytes .../ScientificFeaturesTest.java | 13 ++++ 4 files changed, 13 insertions(+), 72 deletions(-) delete mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.java delete mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.class create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/ScientificFeaturesTest.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.java deleted file mode 100644 index e5047c5..0000000 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.java +++ /dev/null @@ -1,72 +0,0 @@ -package com.zipcodewilmington.scientificcalculator; - -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; - -import static org.junit.jupiter.api.Assertions.*; - -class TestScientificFeatures extends ScientificFeatures { - - @Test - void testSquare() { - ScientificFeatures PaydayTest = new ScientificFeatures(); - double something = PaydayTest.square(5); - Assertions.assertEquals(25.0, something); - } - - @Test - void testSquareRoot() { - } - - @Test - void testSwitchSign() { - } - - @Test - void testInverse() { - } - - @Test - void testSine() { - } - - @Test - void testCos() { - } - - @Test - void testTan() { - } - - @Test - void testInverseSine() { - } - - @Test - void testInverseCosine() { - } - - @Test - void testInverseTangent() { - } - - @Test - void testFactorial() { - } - - @Test - void testLog() { - } - - @Test - void testInverseLog() { - } - - @Test - void testLn() { - } - - @Test - void testInverseLn() { - } -} \ No newline at end of file diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class deleted file mode 100644 index b19ec810423f8ff62c5724d17327ea02e1ea2006..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 828 zcmbtSU2oGs5S(+;qzx_&X@Hg%2p^S_BH?EQltwj`kSv5q6{(LG_Xt_T z5J>z0eiUNP4e$VOIZJ!q-Pzf>z5DU=>vsTq*lEE-t%wG zg*!hMXjv*4&8O6QCC^Xf`Gu%wi}90tr7)?Y*la2wLV?ZKCGRy=V_j$-XP9Ni%K3n| zqyJxm)8b@~Oqs{(P`jyY{reak?BS_=C(*-IJ^;6zeH)vfN zSjHx;e*wS^Y|#U@nf0pT3F`cSjc@RdSsy*glJMsMO4`?ZO@P0=3iFz?jd5O>UWi#eK&$DnE^zg8P9hJcih^w57ko(2>j6Vrv-+LXQfP zOraYo^6=gS+!YMbTq$3Qtu39qq|qP8KnhooVaPge-8cw{MeU*Vg=_FbX%szAxW063 z3YFsFV1sZL4LftCQofeN5QgIzNnsRM8PW&*h#MBS>qf5rkA%AiBy}&kAbYtVKFaw|OSR#ouuBC7tS%$7NMMcYEDCXMHugm|8E#zx)+$78; z>QNP*e^E`M>r_mJzOuB%^PsUK+^SN}Fi>`=oHg!BHEtTC{=TGiu9yEia)BY~D^1OU zCtvcDU4EiuGOS*P-@YqicX>`jkXThzR$>_44(NzBL``~l&Z#K zRq|@j-<&%4$l?awO!cJcOFsZ$xJ5mK-b`7hKZ3odP6U(Gs%apBDQZ(^4!DgwGy-xo z8wnSCh|&j``i#gcT3?>YApQYeTN(7^PSHoNQw(-|!PqG#e!+(*zQQKZLuz_4j6MpQ z4ufUUp@7X`2}~f5X%djeAZ9R2f$!41k~c?hrT<*a42_iNwq0aecEOt9-y!pQ$cPql zPY)T_LhkD!SuNy&9x|zgEa)LQE##pdGOL9=(nIF8kjHw+f)=u Date: Sat, 25 Jun 2022 11:37:20 -0400 Subject: [PATCH 05/46] Created a new folder for ScientificFeaturesTest --- .../ScientificFeaturesTest.java | 13 ---- .../ScientificFeaturesTest.java | 68 +++++++++++++++++++ 2 files changed, 68 insertions(+), 13 deletions(-) delete mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/ScientificFeaturesTest.java create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificFeaturesTest.java deleted file mode 100644 index eaeba9d..0000000 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificFeaturesTest.java +++ /dev/null @@ -1,13 +0,0 @@ -package com.zipcodewilmington.scientific_calculator; - -import com.zipcodewilmington.scientificcalculator.ScientificFeatures; -import org.junit.jupiter.api.Assertions; - -public class ScientificFeaturesTest extends ScientificFeatures { - @org.junit.jupiter.api.Test - void SquareTest() { - ScientificFeatures PaydayTest = new ScientificFeatures(); - double something = PaydayTest.square(5); - Assertions.assertEquals(25.0, something); - } -} diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java new file mode 100644 index 0000000..704680b --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java @@ -0,0 +1,68 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class ScientificFeaturesTest extends Console { + + @Test + void square() { + } + + @Test + void squareRoot() { + } + + @Test + void switchSign() { + } + + @Test + void inverse() { + } + + @Test + void sine() { + } + + @Test + void cos() { + } + + @Test + void tan() { + } + + @Test + void inverseSine() { + } + + @Test + void inverseCosine() { + } + + @Test + void inverseTangent() { + } + + @Test + void factorial() { + } + + @Test + void log() { + } + + @Test + void inverseLog() { + } + + @Test + void ln() { + } + + @Test + void inverseLn() { + } +} \ No newline at end of file From c1f3d5a9fe937f00114dc8b0d64f0abfa64f69ac Mon Sep 17 00:00:00 2001 From: Fitru Date: Sat, 25 Jun 2022 14:12:29 -0400 Subject: [PATCH 06/46] Added test cases upto sine function --- .../scientificcalculator/MainApplication.java | 18 +++++---- .../ScientificFeatures.java | 2 + .../MainApplication.class | Bin 1194 -> 638 bytes .../ScientificFeatures.class | Bin 2418 -> 2418 bytes .../TestScientificFeatures.class | Bin 2220 -> 0 bytes .../TestMainApplication.class | Bin 0 -> 370 bytes .../ScientificFeaturesTest.class | Bin 0 -> 2452 bytes .../ScientificFeaturesTest.java | 36 +++++++++++++++--- 8 files changed, 43 insertions(+), 13 deletions(-) delete mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/TestScientificFeatures.class create mode 100644 src/out/test/test/com/zipcodewilmington/scientific_calculator/TestMainApplication.class create mode 100644 src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 68c1369..459c135 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -5,14 +5,16 @@ */ public class MainApplication { public static void main(String[] args) { - Console.println("Welcome to my calculator!"); - String s = Console.getStringInput("Enter a string"); - Integer i = Console.getIntegerInput("Enter an integer"); - Double d = Console.getDoubleInput("Enter a double."); +// Console.println("Welcome to my calculator!"); +// String s = Console.getStringInput("Enter a string"); +// Integer i = Console.getIntegerInput("Enter an integer"); +// Double d = Console.getDoubleInput("Enter a double."); +// +// Console.println("The user input %s as a string", s); +// Console.println("The user input %s as a integer", i); +// Console.println("The user input %s as a d", d); +// + ScientificFeatures x = new ScientificFeatures(); - Console.println("The user input %s as a string", s); - Console.println("The user input %s as a integer", i); - Console.println("The user input %s as a d", d); } - } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 8cdad6c..5d77ec4 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -3,6 +3,8 @@ public class ScientificFeatures { double result; + + public double square(double num1) { result = num1 * num1; return result; diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index fc066c749c8c888e4c6ad415e30abed9cc1edb0f..da0552715d00204548e460a2a46543f2543cfd0f 100644 GIT binary patch delta 260 zcmZ3*`HzL`)W2Q(7#JAr7$hfh>9esja4<61PTs|&EgPJinVMIUnU@&ozLPLYbu<(Mrj@RL4;F+CwrenKK-?anJ&!>^bR1&(5OPFTZ zrl|6J(RI8Qe=FRMknO;e<(?zB48&{Uj8e;0Pxd^QGbFpdkbx^1EUPw>QxC}9uDlv^ zg$gT5RhD7;sSLPp+GcMUsiYV>W-v=on+IY3f$a9_Ol#*b7si;QVjAYCB@wSQNfvK& zUop??Sin_=3^5;s?udH*57bd~MZ+~pKhxau`c0RY6!o%>>o7ynPloQl6deW=@e0Gz z@d-EkJ?e*0CpK4mrcH0u8x1!ZmM;j2PN`vyVg7=cRuUG&?mt}bp)KU2Zr2r#9SDyu zH&Labpbpf8c{COc+ZW1?oQdE>^cePP|6j5~H9Mq&Va^(#qUf#* z4Z>}|O;u*jff*Pf#_uyifS{By;OvG8Y5klM-4H{%?)80#KNIS}v%mDFq=p`Otkb8d zo*0<=IB6}ARi>TMK2iJx_HhUoX;rXVH)z$v0BmB5tQ1PaB$fPuh!V6{jb!`_Vgsa% z%m9~bMs9#BhsNRnOGidNLD0+iMqR--LSu7itcJ#xGDf9Wpb@1;g;L1S0Ov4;Mfw3) un8sc5JVtgXs~DEXE!?K~40f=MJ0vwn0(U4fMp+i_;XdNzeLyiWJp2LYD>7dI diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class index c83700d0dd248d93dcf2820188428e1868569f67..a2979e643fb9918e365ab73c5a62da3ea1930495 100644 GIT binary patch delta 233 zcmXAiOAf(M6o&suPj5>Q&y;us@kmHYlNvDasDT8P8Zc;Q2JGj~til%9fGt>q6*#WZ z$#>3o{{NHxWbZAFObEnfPxC1S18KQ4>hh)yDF+jI`O?lAi;WVJD8oVpRn(+MAvKUd zQ||S;e3C;QrmiAOcc{-aVDf3mnIo0?&~0*=#)|U7rU}zj(M3en83=R!TcC&~_jqVy q1)HafwS0>!ZP?$kA5g&F;ooi8bmaX>i@DGB5KhS};GY7h#H**zkK{wzQT!Skx zKFJ`QWzVZl}_%U3s}MGlg1)yp_LIX3dJ;c*pELQ%~qA|EM~ z)yDMIlR~O81)4lFq&icBX-!SelsfZaN@_E8G-ZUO9#db_MZ~262t&RbA%`)Fm>|Fu pl6x0(^%hrJu)kz~M;rFG|KFCRJ5O>UWi#eK&$DnE^zg8P9hJcih^w57ko(2>j6Vrv-+LXQfP zOraYo^6=gS+!YMbTq$3Qtu39qq|qP8KnhooVaPge-8cw{MeU*Vg=_FbX%szAxW063 z3YFsFV1sZL4LftCQofeN5QgIzNnsRM8PW&*h#MBS>qf5rkA%AiBy}&kAbYtVKFaw|OSR#ouuBC7tS%$7NMMcYEDCXMHugm|8E#zx)+$78; z>QNP*e^E`M>r_mJzOuB%^PsUK+^SN}Fi>`=oHg!BHEtTC{=TGiu9yEia)BY~D^1OU zCtvcDU4EiuGOS*P-@YqicX>`jkXThzR$>_44(NzBL``~l&Z#K zRq|@j-<&%4$l?awO!cJcOFsZ$xJ5mK-b`7hKZ3odP6U(Gs%apBDQZ(^4!DgwGy-xo z8wnSCh|&j``i#gcT3?>YApQYeTN(7^PSHoNQw(-|!PqG#e!+(*zQQKZLuz_4j6MpQ z4ufUUp@7X`2}~f5X%djeAZ9R2f$!41k~c?hrT<*a42_iNwq0aecEOt9-y!pQ$cPql zPY)T_LhkD!SuNy&9x|zgEa)LQE##pdGOL9=(nIF8kjHw+f)=u$>}P` zj=+`nwS1*U`v>zvwkEd@-pNjrae*F5-)m)cZ&mQET$(Q2Dsr=?v7}WX?*!6o9u*ju zV8(Xj9&@yPXI%GL2^=sJjDG;~7GQM% literal 0 HcmV?d00001 diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class new file mode 100644 index 0000000000000000000000000000000000000000..e2284fb7451e52599c0456fecdd966df884ddecc GIT binary patch literal 2452 zcmbu9NpI6o6h^<7q;VSDHY#OoK^0@#0%4vzgrtQ+Xn~YUEL~&5L#bVC2PAgo*Q^gM<9D!x-y&-NEfHp4deu7{{vI+ zu$LSwZ23-*hk8_qh>=UhA~1@@VaIBRA!3RscLrNMmuCL#tiH;u^$HnCOyAV zdevf1{N0kF=|Hhsomy9>LnaO@Q$995@w`wiPnb9o zFTa(c{jx3_ZuVP}V0NLB8QA2`|hpWV%(i7B<238c%N?bTnOzQ0cy zI4e-z)g4=Nf{@q>t0pi~BYmZ{x#9S0)`lw3Xw75Y)-7MEd9s)ZUrHXmQrorp7H^lz zpq>;bxp#3=^Sk4dZN#Nm6A)E_Lr+@l#7$>i29k#r8`MX&H{T8rILA?m|3a-ye}wqJL5fR=wt*bZb8N-| zxPXhC0hhR&iZ0$jhF{>|7Z}ezVz4$dhWs|nk+;ct7J>S@1|MOL#}8cclD4P zTF5;;WL67V) Date: Sat, 25 Jun 2022 15:08:20 -0400 Subject: [PATCH 07/46] Adding test cases for scientific calculator --- .../scientificcalculator/MainApplication.java | 8 ++- .../ScientificFeatures.java | 21 ++++---- .../MainApplication.class | Bin 638 -> 474 bytes .../ScientificFeatures.class | Bin 2418 -> 2495 bytes .../ScientificFeaturesTest.class | Bin 2452 -> 3529 bytes .../ScientificFeaturesTest.java | 50 +++++++++++++----- 6 files changed, 57 insertions(+), 22 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 459c135..c5d6d3d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -14,7 +14,13 @@ public static void main(String[] args) { // Console.println("The user input %s as a integer", i); // Console.println("The user input %s as a d", d); // - ScientificFeatures x = new ScientificFeatures(); + double result; + double num1; + double equation; + +// ScientificFeatures x = new ScientificFeatures(); +// double y = x.factorial(5); +// System.out.println(y); } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 5d77ec4..6b5edbe 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -44,31 +44,34 @@ public double tan(double num1) { return result; } - public double inverseSine(double num1) { - result = Math.asin(num1); + public double inverseSine(double opposite, double hypotenuse) { + //Talk to Thina about this one + result = Math.asin(opposite/hypotenuse); return result; } - public double inverseCosine(double num1) { - result = Math.acos(num1); + public double inverseCosine(double adjacent, double hypotenuse) { + // Talk to Thina about this one + result = Math.acos(adjacent / hypotenuse); return result; } - public double inverseTangent(double num1) { - result = Math.atan(num1); + public double inverseTangent(double opposite, double adjacent) { + // Talk to Thina about this one + result = Math.atan(opposite / adjacent); return result; } public double factorial(double num1) { + // Talk to Thina about this code result = 1; if (num1 < 0) { System.out.println("You cannot get a factorial of a negative number"); } else if (num1 >= 0) { - for (int i = 1; i <= num1; i++) { - result = result * 1; + for (int i = 1; i < num1; i++) { + result += result * i; } } - return result; } public double log(double num1){ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index da0552715d00204548e460a2a46543f2543cfd0f..ead891c865fa03c80ebdeef8dece06a11b30cbaa 100644 GIT binary patch delta 173 zcmeyza*LVk)W2Q(7#JAr7(^y=nJ`*SwAY@j%E&+Q;O5D@7**@p8JK{Q3_y~Rft7&` zNOA&s`aqfyNV95fXJFh2mgWMIAZZZE4J3IW3V<{(kjKfu$G{I10cq9-Vvsrvjbca| U85sl^1Q{5(fGUN6YMB^>0j7-*8~^|S delta 246 zcmcb`{Evm})W2Q(7#JAr7$hfhnK0T;wAYpjPR>ltE6GgDOm<66EGaEYE#_iiXJBS$ z;GSsnft9g>k->iAMjatcWs@}-HR`z-n1JRn07*s$Rt7d8$phr+18GJe&8oGXfpH^P znioidq(LMfkmP|VVBlvE0P;8)1Q~>YA|TC4Pu;Vw)fX2ZJ!! d5HSUaN+4GRsDlG&f+&L+kYr>K2lAO1BmgC5B6a`( diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class index a2979e643fb9918e365ab73c5a62da3ea1930495..951c4e8de9a41f0ce0b944e67c92b7c14538e259 100644 GIT binary patch delta 551 zcmZ{g%Syvw5QR@nV`9__6|03tr6AR8G=-ud)?&RPDr&vdyJ)}*CdF34l^daZvry1| z!HsxDToh!Iu@bDCupSTC+&|d77cB0=PWuQ;c)rnNRME6&`D@v_loXjnw1w9I6AnaOjd zK?>91l4Dl}oi3$Gnk00}nNV7UW#>RKq%_fU&QxWKuu|4!s97p$R-Is#A+1rf?rP*U I8mhqhFAN1%bpQYW delta 335 zcmdll{7H!G)W2Q(7#JAr7-BbaNiy^CX6BWp78R#D=ND(@rEU&kwr8F!$SKOGKZ#A8 z)qsJ6!Eo|C7J0^?$pV~Wj7A_qQ=p(3STGnYXbKXv0t#A#1cgHwgcukZT!B_BVPIuo z0n%2J53-BaE2;BMpUoh{Vkg_KK4UI}u$I;q26q1Jtqklf%#6$bzX5UA164CKxB*Ee zpm_`o_COOH7`Pc68N?Wz7-Sfn8B`fu81#X(DT4=tJ5YrJP`w<3I728y7?1_D3n=ah zq(Lli1|FbG{DEvP24)_yKMd@QzkmiYGK2%&t;gyOw897MkBG^;I1E_>fffZ#{=gy6 g7zvgS1ImYk<)bDia~iTn1Lb2t^6b$-BbgXt04~Qq!TzkVjLiX+g9}V+XrwQ{1MF9f#7UWa3VoN$r`` zGftr8(ei#j#gYYd!?H*ytw2JEB@2Xv)C~f4#TKzaNC?D#XRgPVdYu%-k?eb(-?=mA z+?((J{puSc8l{gy=2~bd?!~Y{q%F8{jsdlNTSs@Bgog8aLh4?V3 zL7^};f@EDPsYM|Dy@|er96MNcX`$8twJFq2+a&5Si@C^B2{qw+S+})fL|xV+W0s{A zZ5>rhq^OQ?1nKe+>w6Q4z6>L6SE!SbLM~~_G;OBtR_K0Ly{g;U#gv{iY}+;r>tsMmT=W&IS zth6l)Y8L&Vt9dzgzOva<3Y~T;&zm_p`rGWEGdJQAiMuS~0E8v)*k^nrP{ait-_IrQcrE(G~IJ zrpd$DCaWOD` zdS{6pG7$}m=ZMkp%mFTN2ecTOC{1#*luLG1nz_~8<=6dJVTJZd2%B{6`5}r6N44z%60Iw6@Q0( zyN*Y>NC>WD`D9=U9HvZ}#DfbP?A%rJ6~8J4=9}-IxrS0^shHKqbv8R)cOTs><=!QA zMWr4(hpUBs*y)JNg(PC9Lj=DP)AZjY=?g4;^c23CnJ7qe_*Ps8QfVF%Q5II86Fg6T z{1J70O@T8vX-jgTl|pNzOtex{?=5PsbL6`@kLodq3C@*I=)B>{S8#>5bU?z&;>i9|Zdl*u!9t)L=j3 zu`dhQS3I_cVP!McRW)Oew9=z%bO`uS5k3a|7`5QPicX4G;k&#sYoTWyJR6GV1o-Fg z0UrZCF2Wy0(qq6+0Drs&{sj+zRe-;C5BMX%9~0qE0zV1-Dd11nz`y9>UlQP7_V6_h zxZ_}-5V5Dh&fvw*;Ke^t#jZZ!Uh!W1s{;0G8?h(Bo)WRofjtZMd9deduwVDsZwT0L zZp2Q5JtJaY09yll0qk52_FEqNZ2|iok3GjPmG-KJ$02iOA}k_b1UV0K0SCKTMQ-o*Q^gM<9D!x-y&-NEfHp4deu7{{vI+ zu$LSwZ23-*hk8_qh>=UhA~1@@VaIBRA!3RscLrNMmuCL#tiH;u^$HnCOyAV zdevf1{N0kF=|Hhsomy9>LnaO@Q$995@w`wiPnb9o zFTa(c{jx3_ZuVP}V0NLB8QA2`|hpWV%(i7B<238c%N?bTnOzQ0cy zI4e-z)g4=Nf{@q>t0pi~BYmZ{x#9S0)`lw3Xw75Y)-7MEd9s)ZUrHXmQrorp7H^lz zpq>;bxp#3=^Sk4dZN#Nm6A)E_Lr+@l#7$>i29k#r8`MX&H{T8rILA?m|3a-ye}wqJL5fR=wt*bZb8N-| zxPXhC0hhR&iZ0$jhF{>|7Z}ezVz4$dhWs|nk+;ct7J>S@1|MOL#}8cclD4P zTF5;;WL67V) Date: Sat, 25 Jun 2022 16:30:57 -0400 Subject: [PATCH 08/46] Finished test set for scientific methods --- .../scientificcalculator/MainApplication.java | 6 +++--- .../ScientificFeatures.java | 11 ++++++----- .../MainApplication.class | Bin 474 -> 474 bytes .../ScientificFeatures.class | Bin 2495 -> 2505 bytes .../ScientificFeaturesTest.class | Bin 3529 -> 3675 bytes .../ScientificFeaturesTest.java | 7 +++++-- 6 files changed, 14 insertions(+), 10 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index c5d6d3d..0bb1d2f 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,5 +1,7 @@ package com.zipcodewilmington.scientificcalculator; +import static java.lang.Math.E; + /** * Created by leon on 2/9/18. */ @@ -14,9 +16,7 @@ public static void main(String[] args) { // Console.println("The user input %s as a integer", i); // Console.println("The user input %s as a d", d); // - double result; - double num1; - double equation; + // ScientificFeatures x = new ScientificFeatures(); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 6b5edbe..892f93a 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -45,25 +45,25 @@ public double tan(double num1) { } public double inverseSine(double opposite, double hypotenuse) { - //Talk to Thina about this one + //Talk to group about this one result = Math.asin(opposite/hypotenuse); return result; } public double inverseCosine(double adjacent, double hypotenuse) { - // Talk to Thina about this one + // Talk to group about this one result = Math.acos(adjacent / hypotenuse); return result; } public double inverseTangent(double opposite, double adjacent) { - // Talk to Thina about this one + // Talk to group about this one result = Math.atan(opposite / adjacent); return result; } public double factorial(double num1) { - // Talk to Thina about this code + // Talk to group about this code result = 1; if (num1 < 0) { System.out.println("You cannot get a factorial of a negative number"); @@ -86,7 +86,8 @@ public double inverseLog(double num1){ } public double ln(double num1){ - result = Math.log10(num1); + // Talk to group + result = Math.log(num1); return result; } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index ead891c865fa03c80ebdeef8dece06a11b30cbaa..e600e61249691a05c1b4f6946be517af625a4a19 100644 GIT binary patch delta 19 acmcb`e2aNQ3nL@P>vT=iQT#q2)0OSaQuyKarGmK>nVU*Od zY^uyvU>%RSM)9Yfp;jl8d(85FA{|POD(O~A*ibj3giY>js<#y5>OaNe4`};l^s+uh?jVk^fIk`nKq*JVE6xlD}Lh+ zN&H&4M)5(uY6QH@o4R5QwA)R6t(50^GvIYbv0*5?U5#BG@Em>0fQvHVnT&L|X=cYj iUN_SgXlrJqzMCMdV4m1k26mTD+Xl9q(>;2#u>TJl9AxnT delta 1091 zcmaiyJ5L)y6ot?1uDy=&3k;Ttg0Wr1!XT^!MWKm}67jTom`8XdfJH+Si84hBYHI(1 z`~!pn!b$-(F8DbVQ55CO?r1z9TWF=x-QD@loIB^ns1Ro$!yoR`7VPTGI(EDg(o^{0EfCVh_O<)NFTxXkO&d58tH%tb2 z0hg8BpYq-#YQN;Go`yh8kw2V_LBa(DtV={O2UDacG<()$_68BTKOL*CFxXpMw+GOoyn zN91dgg=fe~Mb?73)6R{Llbm>ltmC81ivH{DTXr5V7RF9mC|$uVUcx=+CqHsO#y1S{ zttXm=Ew}4N;#g;lLvmQ+*kEZ>dDGW#3O8HnID1c#=^i3m-Yl3JpOr@Ak;VsVlzV7M zBfbx*CVgzH8@hGtVy@XADpceo$`&$AcL%#(Gc&rG86(*+?9^Yl;twZ5U{5K151BK% z!WmsP?z-EIeod@IMvBT-*Qv diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class index 7fdf07d4531bf37e422bc0bb9e8482fe4b1de49c..a94ba5caa459acc24c024f808d53dca333a898c7 100644 GIT binary patch literal 3675 zcmbu>TWl0n7zglg+U@MJOfU8VrLCj^)V5GIv}k~q?yg%3#ifPrwiSWObUWQn*_|mn zv#o*`@O~>^QStJiy!eQTDMS-PeDuMXnDAmWJo#pfFJ59a{?E+p?8csHF|^5c&N<&X zzwgYPZ?<3m^ZA!V)JGo#sf^0~JpBf}uN9zS@)pP04Y#uq`b51ptTu7c% zLs7#}a;A!`1(IZ|u@B2-(5z_d?{6Pt(gul|m=v_75nVS~cZ)=K+T9DPnVLzcX-&ND zBq&B|3TgOhvqW21pkLMIm7Jl7;cttBZ4$M!L7$;&7+D&=aqX+~Wo-RUiMF$m@|13f z;a_fk_gQ1Z$84ZWqHb%zlr_vyKH2%<=uI&)XfG;8j-9ivSZI$#y|h=LwGN#C;%u#7 z4FA~m*WWifFSEd?MEA46N+&R;+xh%@u{Zh6M^{+LfJFOQNR< z&qi3x0}{nqYHOzD6wZSxXT-=vakGadI$~v>(bHo1rxU-8Ux^89-l#-lY#`{Y9mja& zk6Cvg4@q>4jhAJx<3F!QfB$*0o6UPzqLY?an5T)6$;Dll=DIKVX-c5zZ5_I#VwiX` zF&un>s^hqKL;38al1s{y?2OmObsYUM8QVnL>GYX1Do#%nZU@UC;hb;h_}NK? zZ*P69?YB>JQXrvUpbaB=6mwP?QwbaH?D9dM6JodRX@&Z6`f!d) zCOSn`oN0BK_RK;GP7umt0txgSISnN_>IA5Sfz=W{7#KxM_&y!<8owa_(W|s3zO|l$OC$}}Q%&17sx7WpYsE=eu@VVX(R!-3)^4S8Hs4u0 zfU#4QfmegbENO6bjI(U!@R#WHigwKsHNp<^>^iK7w5S30IuARyqHU~bW8clNH}dQz z*v+t8U~lxWP1nwI_C3F%-MU1ZVBf{FH^JTvdkgHlJ?sV7euQH`x}uGJ-vhgYXLrEf z3VR#uP7nKxYoF!VkF92JgB{}8J79Og?uLD@hyA!~Kf$q|T+QAAdneD{4SNsl9@xDe z_Bq!+&#|9!Z3V^3YOJ}W#_p@9T}!kFd>@aGfR9og{#|LJSP9?kmRTJ=ZSkxqp5gG% z-U1&1ALH@+vFHKtgWwN(@XxvY^Bn$#Tj2MBKfvRMzz>5z4E~4*|Dwyk#Nl6dd5;&| zLD+|Q_9*NzJos@u_y5TZNN5R X=V8x#*zdabrDe82@1eBI=>2~IjEK;~ literal 3529 zcmbuBOKcle6o$_@&e(M)PROfi5~`>zkVjLiX+g9}V+XrwQ{1MF9f#7UWa3VoN$r`` zGftr8(ei#j#gYYd!?H*ytw2JEB@2Xv)C~f4#TKzaNC?D#XRgPVdYu%-k?eb(-?=mA z+?((J{puSc8l{gy=2~bd?!~Y{q%F8{jsdlNTSs@Bgog8aLh4?V3 zL7^};f@EDPsYM|Dy@|er96MNcX`$8twJFq2+a&5Si@C^B2{qw+S+})fL|xV+W0s{A zZ5>rhq^OQ?1nKe+>w6Q4z6>L6SE!SbLM~~_G;OBtR_K0Ly{g;U#gv{iY}+;r>tsMmT=W&IS zth6l)Y8L&Vt9dzgzOva<3Y~T;&zm_p`rGWEGdJQAiMuS~0E8v)*k^nrP{ait-_IrQcrE(G~IJ zrpd$DCaWOD` zdS{6pG7$}m=ZMkp%mFTN2ecTOC{1#*luLG1nz_~8<=6dJVTJZd2%B{6`5}r6N44z%60Iw6@Q0( zyN*Y>NC>WD`D9=U9HvZ}#DfbP?A%rJ6~8J4=9}-IxrS0^shHKqbv8R)cOTs><=!QA zMWr4(hpUBs*y)JNg(PC9Lj=DP)AZjY=?g4;^c23CnJ7qe_*Ps8QfVF%Q5II86Fg6T z{1J70O@T8vX-jgTl|pNzOtex{?=5PsbL6`@kLodq3C@*I=)B>{S8#>5bU?z&;>i9|Zdl*u!9t)L=j3 zu`dhQS3I_cVP!McRW)Oew9=z%bO`uS5k3a|7`5QPicX4G;k&#sYoTWyJR6GV1o-Fg z0UrZCF2Wy0(qq6+0Drs&{sj+zRe-;C5BMX%9~0qE0zV1-Dd11nz`y9>UlQP7_V6_h zxZ_}-5V5Dh&fvw*;Ke^t#jZZ!Uh!W1s{;0G8?h(Bo)WRofjtZMd9deduwVDsZwT0L zZp2Q5JtJaY09yll0qk52_FEqNZ2|iok3GjPmG-KJ$02iOA}k_b1UV0K0SCKTMQ- Date: Sat, 25 Jun 2022 17:03:39 -0400 Subject: [PATCH 09/46] Added display method class --- .../scientificcalculator/DisplayFeature.java | 54 ++++++++++++++++++ .../scientificcalculator/MainApplication.java | 2 + .../DisplayFeature$1.class | Bin 0 -> 1416 bytes .../scientificcalculator/DisplayFeature.class | Bin 0 -> 732 bytes .../MainApplication.class | Bin 474 -> 474 bytes .../ScientificFeatures.class | Bin 2505 -> 2505 bytes 6 files changed, 56 insertions(+) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature$1.class create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java new file mode 100644 index 0000000..502ed79 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java @@ -0,0 +1,54 @@ +package com.zipcodewilmington.scientificcalculator; + +import java.awt.*; +import java.awt.DisplayMode; +import java.awt.GraphicsDevice; +import java.awt.GraphicsEnvironment; +import java.awt.image.BufferedImage; +import java.util.Locale; + +public class DisplayFeature { + + public static void main(String[] args) { + + GraphicsEnvironment x = new GraphicsEnvironment() { + @Override + public GraphicsDevice[] getScreenDevices() throws HeadlessException { + return new GraphicsDevice[0]; + } + + @Override + public GraphicsDevice getDefaultScreenDevice() throws HeadlessException { + return null; + } + + @Override + public Graphics2D createGraphics(BufferedImage img) { + return null; + } + + @Override + public Font[] getAllFonts() { + return new Font[0]; + } + + @Override + public String[] getAvailableFontFamilyNames() { + return new String[0]; + } + + @Override + public String[] getAvailableFontFamilyNames(Locale l) { + return new String[0]; + } + }; + + + } + + } + + + + + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 0bb1d2f..ea3ff50 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,5 +1,7 @@ package com.zipcodewilmington.scientificcalculator; +import java.awt.*; + import static java.lang.Math.E; /** diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature$1.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature$1.class new file mode 100644 index 0000000000000000000000000000000000000000..154f4743c3dddeb12db36adab4785af063766c82 GIT binary patch literal 1416 zcmbtTT~8B16g|@x7E3|oQ$EBGP+9~wnrK2$5~Wl~DlZsbd>XdXGG=zR*_|!ouhJ(I z6a4}HDC3=WsoPR{&~3JN=gvLno_puc&tKnu0N90_M+R93xdMhT%&_!I=)hT#`dOS8+6EtXCkj4;ey0hC2cdcr}TVXV7Z3AAxgV3=sT6xR*+ z*o0Cy9E>yUc!BSJl1(qDiF2uZ@|!@rktZpwtV_@1%8L~@LFkrc)KvVUBDje|vHFA| zw?{CBn^mdBQS6_J@Et!@3y|Z@?`@%+l0vPfAmDt$UsL9ZZj-&Lk|S6DG^280EStjFN->lRZkX%#bW829OI;j z8*!PN;aTxdwDfsHxUb`SU4)``XjeM}$exx-Y*zXWhUM$Q45K9Tl~VS2sR5Hc4X{pP zTC^c8E|on4>#J~Is*5A;3xdpaA*q=l)LNoDHd49mV_96ptbi;U325?%Btomu??O4}H00nf0uH1^YrD8BEZ>-3D&a4=8j3Fo`KzF-&8I zqI$sD?{GfTW*R&_06a@EIii@OcODA~%?7P(x(w^*m``zJ5&>zBMJy50N_kG!)_0X- zxy>=#*-bdC(mPmg=eFWiRbE99%N=nL5w-@*EU;ucuA6)zkcqIXEleOxHDDxHY nW~zY8%=QRZ@sMCSJhEkD4Mnm!l<*jvZBGeXWb+g=MwXu6{6jW@ literal 0 HcmV?d00001 diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class new file mode 100644 index 0000000000000000000000000000000000000000..d0f3508915e746b4e7ccc580e4cae08f8d58cc17 GIT binary patch literal 732 zcmbVKO-~d-5PiKfuDl!3g8HvK zVKngv_@j)kT>?lrap?N$diAQS`uCq7zW{7uJwXjo9dU{YObW~o&+*ll+4vAm%en_ zTT=~l`DI5-KXO_iIT;7`w69}EpndOJ&t4`-5edZG>_cF#W31jE6+P{aWG`oAu~V{> zu5>2&m%-Sdnu@%gdlR=wSx93AmNq_iu19z19VgLlb$KscpCrvYt_8$rf%P#?p8IUq z$>FI{)jNA;Txko=kPOLTIdV$xnDCJ1|5JPsI0dHnb>;VTcrdxr_tt8+oy)4y6`pcq zHSQXSAi|O<=jdhBf_mcl1;jTRHOy0nYaqb_Wjap4BAWCXcz}nD1n?$L$cw+DevJ)( z378?#>7-axLTm{wu delta 19 acmcb`e2aNQ3nL@Ppd{TIW2PbP30|!I&WM9re)_4YPhJ?u%SmoIh7#J9s7!m=dWe3&( delta 35 qcmX>pd{TIW2PbPJ0|!IYWM9re);I=khWN=BSmoIh7#J9s7!m=d6$jD) From 6ccba7e0089656e5bc3c69b9aaf4b688cfcfd92b Mon Sep 17 00:00:00 2001 From: Fitru Date: Sat, 25 Jun 2022 18:40:44 -0400 Subject: [PATCH 10/46] Fixed the class names --- .../scientificcalculator/Console.java | 2 ++ .../scientificcalculator/MainApplication.java | 9 +++++++++ .../ScientificFeatures.java | 2 ++ .../scientificcalculator/Console.class | Bin 1811 -> 1811 bytes .../DisplayFeature$1.class | Bin 1416 -> 1435 bytes .../scientificcalculator/DisplayFeature.class | Bin 732 -> 655 bytes .../MainApplication.class | Bin 474 -> 474 bytes .../ScientificFeatures.class | Bin 2505 -> 2505 bytes .../ScientificFeaturesTest.class | Bin 3675 -> 3684 bytes .../ScientificFeaturesTest.java | 11 +++++++---- 10 files changed, 20 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 83f0e97..c44847d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -11,6 +11,8 @@ public static void print(String output, Object... args) { System.out.printf(output, args); } + + public static void println(String output, Object... args) { print(output + "\n", args); } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index ea3ff50..8b3edac 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,5 +1,7 @@ package com.zipcodewilmington.scientificcalculator; +import com.sun.tools.javac.Main; + import java.awt.*; import static java.lang.Math.E; @@ -8,7 +10,13 @@ * Created by leon on 2/9/18. */ public class MainApplication { + + + + + public static void main(String[] args) { + // Console.println("Welcome to my calculator!"); // String s = Console.getStringInput("Enter a string"); // Integer i = Console.getIntegerInput("Enter an integer"); @@ -21,6 +29,7 @@ public static void main(String[] args) { + // ScientificFeatures x = new ScientificFeatures(); // double y = x.factorial(5); // System.out.println(y); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 892f93a..233ff87 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -5,6 +5,7 @@ public class ScientificFeatures { + public double square(double num1) { result = num1 * num1; return result; @@ -23,6 +24,7 @@ public double switchSign(double num1) { public double inverse(double num1) { result = 1 / num1; if (num1 == 0) { + // Should be error System.out.println("You cannot divide by 0"); } else { return result; diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index 1b66f5821543365e55f466fe7eef909f33bfce8b..a8b306711b469d1b2c4ae8dc32fa0b562b0eda4f 100644 GIT binary patch delta 47 zcmbQtH<@q46IND11}+An$uC)>c|{qx8N?Wb8N?YR7$hbKviUN~OrFnX$*3^-CYu!i D_Mi$G delta 47 zcmbQtH<@q46IND!1}+AH$uC)>d4(Cc8AKR_8AKT*7{n$AviUMfO`gwY$tXAZCYu!i D^)w0z diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature$1.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature$1.class index 154f4743c3dddeb12db36adab4785af063766c82..c7a41707ca0e1a358f7a44b7d50a63bf3a50b877 100644 GIT binary patch delta 125 zcmeC+p3Tj5>ff$?3=9l*3sj0w6(%2Jv0+r5%*<-Ts5RMv Z)lggyXgU*vCWAhZ=3-!E;04k^003va92Nio delta 106 zcmbQu-NDUu>ff$?3=9l*4Eh_n0-5>P7#X-yGK&jx5-WXEOD5Ma2TbN<5t;meS(8y@ zG8c<8qvT{iASpL_5{nz7^5mN=HjEmR#aL|^bteb28j9-zjbdWZWY7cBTnvm1yg(WV E0O|D>n*aa+ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class index d0f3508915e746b4e7ccc580e4cae08f8d58cc17..6a502f1c2a064c750454d7a1da649fe1c82cf9ed 100644 GIT binary patch delta 220 zcmXAjK@Ng26hvRaQmB9;il|%n#3eB?aqk5@jYlx*Nm!X^;sM;d^DM^S(#7=8bpA`f z`mF8y_jmz2Ru|huhFGz^<*Lor8;c<{3>B?Qx=*c2OCW7T6`Dviy$01OlgJscfXNq9Jp?Q?rnJAW30Z KdVrEI`|}5Y;SlQp delta 307 zcmZ9HO-=$q6okK?A7-X)U{Dkk;Q(w%*bow}i-9?Bsnm{TP3~zRe@b z*~7E%@E4n=`HJym1|LI6Nmy0aQ#Gn#cZpeuc%;Jo8Z0%TI|#VsN?k&oYfW-ET|CAC-+~igUpF5#Pi+j~T Lb4Odu7EA>8!pj)m diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index 68129c00cf0482e2a198be4ba31a0733fa54f602..0166292afb860d060668a2cc76366728589a02b2 100644 GIT binary patch delta 19 acmcb`e2aNQ3nL@X7-axLTm{wu diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class index 57b8bd47704705d22a117c317022cd2884dbe0c3..023cb4650126c4f53cd1e80853c38f5dca7ff655 100644 GIT binary patch delta 229 zcmW+wOG^S_6g|Xu=b?ngXgZ;eVuCJw8)7XALPv#>nMDOYps9_x>c8A&f5QLJLT0D` z$3@p!-SfJf6Iqe9_Z20eBgt=SK`9tWvu8SdP#wy^M3&F$`^J{U9j;M89wih}<{w&7 z6-nIlkpij-RUK{`kHxI*|36~`>$ delta 229 zcmW+w%L)Mj6g_F~JP2vTkfBjnP?!=WHVjH0Q)a^g*~rSj+@+uJ4;HfHe=J!>ZE7P5mp|&3x`KLwvOLvBG!Qlv=I~v+*dq|e^5-FgiF8a+!3-U_ peayM5pJ^%ER^hgX?$SoGLD-QqnzR*fC!SAx(GP!JI{=8__yhPJESmrT diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class index a94ba5caa459acc24c024f808d53dca333a898c7..cbbd412d17647b7d37cc20751a67144683902ef3 100644 GIT binary patch delta 367 zcmW;E%`O8`0EXc+i_*W-Qi)M1jRhh?ElNbHBE^DE1Z{F?gh?~05t*3`Dei)tt(%a> z#?l>Fij~9_xB_oZzT{gxi}$LVh{UfVn54}Qt^x9}$DjA?58lkb# PceIb*qYvn#F6V0h9EC>z delta 371 zcmW;EyGp}Q9Dwl?p*FVtSEXvO1_y70RnUrq7x0q7%U~4JdZ1bqOp90(Xtd8E!{^6L z&9dzDuiuw~vX!VIRaA}|Oqaw-qpX$^I)aX(V@7|`GCF~}=%mq>tz`w8m;FVvW@PjlG;^e<)tsVuIwTE$N_SQIBAe? z$PwzJ$LNXC_q>)GTIYGnQ=6w>&~k>JqfPX}=o@;4hG+|Iqp{o|9pn~?P4_BV67&we KM|(!MinITzu}7r< diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java index a142809..f8dd020 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java @@ -2,10 +2,13 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.*; -class ScientificFeaturesTest extends Console { +public class ScientificFeaturesTest { + + @Test void TestSquare() { @@ -25,7 +28,7 @@ void TestSquareRoot() { void TestSwitchSign() { ScientificFeatures switchSignSwitch = new ScientificFeatures(); double switchSignT = switchSignSwitch.switchSign(5); - Assertions.assertEquals(-5,switchSignT); + Assertions.assertEquals(-5.0,switchSignT); } @@ -75,8 +78,8 @@ void TestInverseCosine() { @Test void TestInverseTangent() { - ScientificFeatures inverseTangetTest = new ScientificFeatures(); - double inverseTangentT = inverseTangetTest.inverseTangent(50,110); + ScientificFeatures inverseTangentTest = new ScientificFeatures(); + double inverseTangentT = inverseTangentTest.inverseTangent(50,110); Assertions.assertEquals(0.4266274931268761, inverseTangentT); } From 3a3d09a18eb9f461e458840627b62e8c12f8a100 Mon Sep 17 00:00:00 2001 From: Fitru <51715717+tfitru@users.noreply.github.com> Date: Sat, 25 Jun 2022 18:45:52 -0400 Subject: [PATCH 11/46] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 2d815ea..cd6957b 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -Dan + # ScientificCalculator (maven) ZCW From 181d46f281937ffeed0e78938ace9080f9285b75 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sat, 25 Jun 2022 23:19:18 -0400 Subject: [PATCH 12/46] Added Octavia's code & some edits --- .../scientificcalculator/Console.java | 1 - .../scientificcalculator/CoreFeatures.java | 70 ++++++++++++++++++ .../scientificcalculator/DisplayFeature.java | 39 ++-------- .../scientificcalculator/MainApplication.java | 3 +- .../scientificcalculator/Console.class | Bin 1811 -> 1811 bytes .../scientificcalculator/CoreFeatures.class | Bin 0 -> 1737 bytes .../DisplayFeature$1.class | Bin 1435 -> 0 bytes .../scientificcalculator/DisplayFeature.class | Bin 655 -> 471 bytes .../MainApplication.class | Bin 474 -> 651 bytes .../CoreFeaturesTest.java | 17 +++++ 10 files changed, 96 insertions(+), 34 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class delete mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature$1.class create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index c44847d..fa8cd75 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -12,7 +12,6 @@ public static void print(String output, Object... args) { } - public static void println(String output, Object... args) { print(output + "\n", args); } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java new file mode 100644 index 0000000..a37a81e --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java @@ -0,0 +1,70 @@ +package com.zipcodewilmington.scientificcalculator; + +import java.util.Scanner; + +public class CoreFeatures { + + + //A state, representing the value currently displayed on the calculator (default 0) + //Get current number on display + //Clear display + //Change number on display + //Calculate the square (x2) and square root (√x) of the number on the display + //Create a calculator that can perform addition, subtraction, multiplication, division + //Calculate variable exponentiation (xy) + //Calculate the inverse of the number on the display (1/x) + //Invert the sign of the number on the display (switch between positive and negative) + //Update the display to Err if an error occurs (eg: Division by zero) + //Errors must be cleared before any other operation can take place + //Each operation should automatically update the display + + public double firstNumber; + public double secondNumber; + public double answer; + private static int displayMode; + public static void setDisplayMode(int givenDisplayMode) { + displayMode = givenDisplayMode; + } + + + public void calc(){ + double answer = 0; + String operator; + + Scanner Calculator = new Scanner(System.in); + + System.out.println("\\\\CALCULATOR\\\\"); + + System.out.println("Enter first number"); + firstNumber = Calculator.nextDouble(); + + System.out.println("Enter math operator to use for this calculation"); + operator = Calculator.next(); + + System.out.println("Enter second number)"); + secondNumber = Calculator.nextDouble(); + + switch (operator) { + case "+": + answer = firstNumber + secondNumber; + break; + case "-": + answer = firstNumber - secondNumber; + break; + case "/": + answer = firstNumber / secondNumber; + break; + case "*": + answer = firstNumber * secondNumber; + break; + default: + System.out.println("Incorrect operator"); + break; + } + + System.out.println(answer); + + } + + } + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java index 502ed79..6e7e742 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java @@ -2,51 +2,26 @@ import java.awt.*; import java.awt.DisplayMode; -import java.awt.GraphicsDevice; import java.awt.GraphicsEnvironment; -import java.awt.image.BufferedImage; -import java.util.Locale; +import java.awt.GraphicsDevice; +import java.awt.geom.AffineTransform; +import java.awt.image.ColorModel; public class DisplayFeature { - public static void main(String[] args) { - GraphicsEnvironment x = new GraphicsEnvironment() { - @Override - public GraphicsDevice[] getScreenDevices() throws HeadlessException { - return new GraphicsDevice[0]; - } - @Override - public GraphicsDevice getDefaultScreenDevice() throws HeadlessException { - return null; - } - @Override - public Graphics2D createGraphics(BufferedImage img) { - return null; - } - @Override - public Font[] getAllFonts() { - return new Font[0]; - } + public static void main(String[] args) { - @Override - public String[] getAvailableFontFamilyNames() { - return new String[0]; - } - @Override - public String[] getAvailableFontFamilyNames(Locale l) { - return new String[0]; - } - }; + } +} + - } - } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 8b3edac..864abd6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -27,7 +27,8 @@ public static void main(String[] args) { // Console.println("The user input %s as a d", d); // - + CoreFeatures x = new CoreFeatures(); + x.calc(); // ScientificFeatures x = new ScientificFeatures(); diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index a8b306711b469d1b2c4ae8dc32fa0b562b0eda4f..2ed8ec9da0bc9c502d12414fbd7d44f996ede1f3 100644 GIT binary patch delta 47 zcmbQtH<@q46INCM1}+A{$uC)>c|{nw8AKU`8N?VQ7{n(BviUMfPoB?a$tXYhCYu!i D_38={ delta 47 zcmbQtH<@q46IND11}+An$uC)>c|{qx8N?Wb8N?YR7$hbKviUN~OrFnX$*3^-CYu!i D_Mi$G diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class new file mode 100644 index 0000000000000000000000000000000000000000..2af6de1ce32f88343e21770d16acf32d4af80a53 GIT binary patch literal 1737 zcmbVNTW=dh7(L_LZk$cxxJ{b0G<9!@?UHV<4vm{au$#ulC2%egwYH=On(%Oeh1 zj8tvM3fZq4LDJJzm)WWto-J{AFebAoaHaY`uR)O&)wcX{|5b=(E0R%a$9`xz`)8zF zOjb`$2KR4$SSzKMca9|)uIRr~Jank$8|H%*qt%TgS#vv{X)W2Zyhi&k>RDORI8JFJ zd@o`UvgFtkQs=suh#9a<2KO% z>bS!Z>3oqkSaI;zzDgNOfX(`CAO#eTI=27@Lnh z!$kVEJxob^iZ(wP+r#wN$jgDV9FX|jszjIirVF$4@kk*t8Q;T|FUSDcV#~AXY`d6o+_m zrNDWrKn)NI91-J?6(i{R3+~|qG8h&~Y~Vw#`-tmLV(@P~MnZwg|D|~aL;SK1Mn*=o RDUH8BD5}86TpGbA{{Zvnc{>0A literal 0 HcmV?d00001 diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature$1.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature$1.class deleted file mode 100644 index c7a41707ca0e1a358f7a44b7d50a63bf3a50b877..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1435 zcmbtTT~8B16g|@x7E3`sq$ov11!)mkHPM8iBuc4}R9-N=_%v*%Wz6hsvpZYFU!_kb zCi(;XQN}y%Qrl8_&`ow{=gvLnp8GLBe|`G_Ucz zc`ChVPq$%QPMC8DV7z>p{UvZ(V|^+jPQ6iZjcm?TBq zh>O?^&x(J%rOz9}eI3{9A{4a)yW1W@_Owi5)6#D+EL{y|7$=#pl(Oxm0?hOkz#56E zU|m{VD%%5Vt8ibc^F!_ng3NUxJu^Y5wM2Jpq;lJBB&|tx`#qVmjc(Vn*O}^l6vUw? zD$p@__W z5YdIo9cV4WUB#nFL|DcIT}S&k^wNa{Nu)oQR%R{hU%|f6PYP4?wa36Drsff$?3=9l*3?dV`Oc*UE+FMTCw`uZJM#XvtMFw^TCZHSxkYr?FWncr6 zoIsvFkY)tZtXkU{7&n5Yxqu`{nt_3ffg4EjKokIJULcQ?fscV7C<4-~4a6XI7#f9< TG%_*>Fz^b3RSE$~CI(>u>wgaD delta 284 zcmXAk%}T>S6ot=ijA_!e+N$vn1f|erkh&>Cp@@i3-MbuRz=|Cu6KZ#T1POhTx)Cb) z0KR~4Bc4oWaps;o=YE&@_1^vH=WqE9ppU~MI+OEa(W|#lBLwgQ)C4^?is{FROa({7 zCpA&2ddt(ROuasi9_*!=jItLq)+V2Kq}>(NZne#C^!Q$9RuEqsqqB==Wv#Y2MuZBN zfhzE^PL1bEl3AU-(t(KvHFmX+4Q$edXrfhSSr0f{GQuwecb^D{3z`Z_zzW_#6{&+H ht01kw diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index 0166292afb860d060668a2cc76366728589a02b2..a4d4c23d66d31b632f116f69fcdf43e51be258cd 100644 GIT binary patch delta 259 zcmcb`+|9~$>ff$?3=9l*3^EhBOc>24+H0#i=NF~Ar6!h?7Nr(*F|ac*g9vUO1|9}B zMh2GT#GGVy2EK_lA6OYH7#S=lZq(sH)-hR=QKO!hfeC0R1CV57U}azflKeoPK9FVv z(yUtB85lQ$r3HW_NSXm?x*(VYD_{^}5C-x%8AKRFp_)B`hJg&_-Oa!rxt)R2M|&Fs v7s3!e24ff$?3=9l*3?dV`OeRizH+es!YCSsx6Htr+NHQ|8GOz(jP9RSoNHYRy zR;}#}j2pqyTtE^e&A`CJzzrtB3V=LbAdi!QkAWYmSsTa)$zf Date: Sun, 26 Jun 2022 00:01:14 -0400 Subject: [PATCH 13/46] Chaged the case statements --- .../scientificcalculator/Console.java | 48 ++++++++++++++++++ .../scientificcalculator/CoreFeatures.java | 31 +++++++++-- .../scientificcalculator/MainApplication.java | 4 +- .../scientificcalculator/Console.class | Bin 1811 -> 2831 bytes .../scientificcalculator/CoreFeatures.class | Bin 1737 -> 2939 bytes .../MainApplication.class | Bin 651 -> 683 bytes 6 files changed, 77 insertions(+), 6 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index fa8cd75..1a44927 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -7,6 +7,54 @@ */ public class Console { + public double result; + + public double add(double num1, double num2) { + result = num1 + num2; + return result; + } + + public double subtraction(double num1, double num2){ + result = num1 - num2; + return result; + } + + public double multiplication(double num1, double num2){ + result = num1 * num2; + return result; + } + + public double division(double num1, double num2){ + result = num1/num2; + return result; + } + + public double square(double num1) { + result = num1 * num1; + return result; + } + + public double squareRoot(double num1) { + result = Math.sqrt(num1); + return result; + } + + public double switchSign(double num1) { + result = num1 * -1; + return result; + } + + public double inverse(double num1) { + result = 1 / num1; + if (num1 == 0) { + // Should be error + System.out.println("You cannot divide by 0"); + } else { + return result; + } + return result; + } + public static void print(String output, Object... args) { System.out.printf(output, args); } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java index a37a81e..25cc694 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java @@ -1,6 +1,10 @@ package com.zipcodewilmington.scientificcalculator; import java.util.Scanner; +import java.awt.DisplayMode; +import java.awt.GraphicsDevice; +import java.awt.GraphicsEnvironment; +import javax.swing.JFrame; public class CoreFeatures { @@ -26,9 +30,22 @@ public static void setDisplayMode(int givenDisplayMode) { displayMode = givenDisplayMode; } + public static void setDisMode() { + JFrame frame = new JFrame(); + frame.setSize(800, 600); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + GraphicsDevice graphics = GraphicsEnvironment.getLocalGraphicsEnvironment() + .getDefaultScreenDevice(); + graphics.setDisplayMode(new DisplayMode(800, 600, 32, 60)); + frame.setVisible(true); + } + + + + public void calc(){ - double answer = 0; + answer = 0; String operator; Scanner Calculator = new Scanner(System.in); @@ -46,16 +63,20 @@ public void calc(){ switch (operator) { case "+": - answer = firstNumber + secondNumber; + Console sum = new Console(); + answer = Double.parseDouble(String.valueOf(sum.add(firstNumber, secondNumber))); break; case "-": - answer = firstNumber - secondNumber; + Console sub = new Console(); + answer = Double.parseDouble(String.valueOf(sub.subtraction(firstNumber, secondNumber))); break; case "/": - answer = firstNumber / secondNumber; + Console div = new Console(); + answer = Double.parseDouble(String.valueOf(div.division(firstNumber, secondNumber))); break; case "*": - answer = firstNumber * secondNumber; + Console multiply = new Console(); + answer = Double.parseDouble(String.valueOf(multiply.multiplication(firstNumber, secondNumber))); break; default: System.out.println("Incorrect operator"); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 864abd6..fe4c476 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -28,7 +28,9 @@ public static void main(String[] args) { // CoreFeatures x = new CoreFeatures(); - x.calc(); + // x.calc(); + + x.setDisMode(); // ScientificFeatures x = new ScientificFeatures(); diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index 2ed8ec9da0bc9c502d12414fbd7d44f996ede1f3..bfb108da0f0d4878dbe74fcb8fd80c5ba4e140d5 100644 GIT binary patch literal 2831 zcmb7`?RFDY6o%iEw4HP^O(BI+5U^ArX<7-NqNZY@p;Ac!2^JB*rjsEZI++Rc0oFU< z3Uqk`{8U*AEL`e;uf{8I`JR~}4Kfw%TAev_=Im$h{qB9v3vxb z)&vIpJ02Gfl7s z&(u4$9QF!~-*Cf8Lw6iEm~2^ht(G~tx-ofF#eTf5U{b>YObLvo*b69KNwXa~D90Wm zxrk@>wdoZJIjG?f4l~tg?Ja@1l%+TOtYfij)2SgBnRHphG%5nSI{LavDGfciZUt*n z)IfIvU*K?xi-gx7pvnr)YIqYz1O}t<1j;F*Zgp*o^@=8Pvfcb>ION|6b&nCM@!+cKvTIfU zo)s8tO{-0F#d7YNp3gNS%|JKSm-TLvzz|!U%F6UMH%-!mj79g_Om8fuh>WRi%8IaC zBjuwmbvs?M6hE#fEn{kbk(u{!=$l?*G)l^n6PWGZOev*{`b(9pCPzk4cSDvVfxWDE zPXWl8-YmEGQgT_k(#mDv|k+3Q=d zcac5u%Iu|7wz~y;FWLKEnf)P(iQaXp9cfr8m9~oe0NGO!dpy$rMZEq11;Q>6LIKDWO24hg?j8EL2K6Ft$~gGyD}W+s7>Qn1vp5xyS4#%&E#~ zNs3x3eEU5L53#fO+9T|HfLzph&)P2=weWbfw?eI1EIyN7@HxKVJx9iu{5R3&lgiN=Zo|gze*lML BI!pin delta 772 zcmZ{iT~8B16o%iK?RMMQwNP41p_K9^;I_D0zrRqasAxeF5)GFdtx2`Eq%Fp~dW$#O z%nwm9kp`m|#w+9h@s4h+*g^&)3`HrlqRF6d zC;`K)?1mEZt)85CWMGsb?g2O3)ta;R#I4sW%_t%mvoMYcxz2NuET$~zI3eHg>_{3j z7G@RK@OZVlKo+)zJPPsyfB*T1Hp5~if!kO#a7WE_SN;k8%q%f*CK#+G)uL2$TdhjV zK$#Jkg-69yxzTvBxnW>M?&))#G&s2cgh7*g>l|ecWsG*+-U0hW0mrGJ2sE@qvE>)w zG|o`Ar97Y$C0>B$LB%!_O9i{*dknP5=Q|-BsoS2V5h|3gjg61GA0oiOxz~x_1a!o?JBz~ z8Ay6b(&p0Uekb>|Nl2UYL(@huWu`x%)35m#o$1%~OWWt&m5`h;ok26N-rKpo=RD_} z{ri9Z`ZoY$_+tVwv?+*dXh(-Y&l$a{=WN|s%1zIoF^xc=W3S~{!I(f>Iy2J=6`cwa z8oHnf++(<<+y$#_xC`crWtS{xDR7;fZ&;=iSc{fn=(bU@^}zLV{p^z`zw zW%vi2s^z&(iPj5jUNVD%%NJbtHkHm4{vZEn0)4nuLkhPEY@n#RVMW6;O($+>~zG7oCk}W)x(2b4^md z8H5DV7?dculRl+awq0Ymwh_K_xOIJ2mXWZh-{ZW-Q;DxB1$5 z`g8=L5e@g?N5q!y_$#JI0OS?iE6^KSRtYRSS2T3TF}+Ug#XbdN8t%jWtMFMo?+0c{ zAZ9VV>!Y_?Zf?>kSAt^TnR;0Ou|rZgPIw7|O1d}?Unqc_V^iY=|I+Ysg#Z6wU; zE)@?F`UjlA^iqqK=LadLQkpkCX?;<{ah#wV9rIj}cPpVAnTUCrh$l6il3wfzxsHZR zDozXJB4H&xSWdZN4!B+_a8niEOfAagvgM~5smb(^n&ve87(Zc*q$Y`;I=owLRq-fq zBH_MixXwb|)QmJ|UV|ac(W0x!o&-!RDp=C63~P1#!uJcP%eucj9+m+qB1RB=JW z<9LFQ&=(eDt;y#zd1=(oH2fUDU{tHRT`{K@rB(Us_$q;?@U((oYWNkNS@rNn7`w{4 z=bMe)s<$<;L5)>Br{Q^NNta)l4?NwF1x=p+M#Bs8TwSoL%&_S2B@Hjj!|oD`pjEal zBP@U_UM0pR9mDlJR`qMBkN|#NqW2A%o%zfRrzjR{3zlO>F+8q^uuF!;a7Onmxvw9_ zC6)yC6mH1X%}y{%*DP68R>aoYBC7@uqUO-PC>sHR7v}it_CR)Zsb0KUlA0B-QM2o{ zl+TiQXE^-|YsT&yGdDyARgrm~|MWN2)*XDF%SMjT#gPTANyFqFzt#m=BO;2{8b`@% zih*vNozly7wlAG5 zynmCs9B09~J$o7APh7W!VMp(oo>!%bJPsfK~VV77)WgIAHB zjjnrAJ$o;MheO$T4R<#+Z>Pz?7W!fVz`FaWH8%83@-9}3AmfxdN+C)s7(xCij66aQQXBIJy1Rc?{C^ThR4i1ZY>F dDlir7;Xm`FySuw0_rbW=F#t&ek z*(W~%i7_#vmP8ZZ_1PC6G%-G!nE0kKQU7NFqnpf`{mq#p( zo7qBoAzzT$kIU4L3#c8*&M5&cohvS73s${WwE7%XVYOpan*FnLi`iUqu6T1kedkzy zCd+_KdOl-~>32&kjxQ`^#ncZH!FzTE zzE#vF)D_fKZ!V)r>Q-tqq?XbC0;V)iuO5K15uJYs=V99=5q%l^h`-wmIOG>?e=ftZ8wrR+G2Lr;wjQ zX#`64h4O-=`5Y!Co*7w2?*_~g+BP6hsM~<+1dlB0=vwX3GLFe-RqUQjp_cz)zHKuq z(TV`t(ZqtH=wx{&c5tc(*y_?D;yd)^YPQ*_ngcEy&3j@NBK@sGf z$|jp^1lxeMCObp`a%u!4KjR$EGlfdwMhX|`cai=r@chPYXgXYqj)V>`SI&aZ=c_TA P41Pb@SbQ+JevhSk diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index a4d4c23d66d31b632f116f69fcdf43e51be258cd..99edb7409c1bc8f5deb0faef36b12b739f4bd481 100644 GIT binary patch delta 227 zcmYL@yAA!ICYa3Y)m7FR3f8 z#O=-%bvAWQG^!y%-l!Q+peV_sMEQ3-7FY!JA2_os-Y~qN!|9FWpX3vhMU$ROAix$` X+6G(vo>HMI0~bw=y7{Id*`oOYSI`!@ delta 187 zcmXAhyA8rX5JcY@oj)gh1`LP!2qGePKmZ{^q5+yAASJR~29XnxK%xNJpbx~JNoIFv zcHUKAw0VCYFJQyGGUqVDD%RDutamDFK84Ct0*Mh-XhPAfwt+kK#Pb()>9^{4&465H z!jO^wm3=Q=&q$v{$2-ZPykQzK0zAah5nT|o6x6DPxqku2Sh85K1rxz3rfqNb1M;I0 Ao&W#< From 3278c915d9b3b135447cee851fa7b6e9bbbe9bf0 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 09:07:49 -0400 Subject: [PATCH 14/46] reverted changes --- .../scientificcalculator/Console.java | 5 ++ .../scientificcalculator/CoreFeatures.java | 69 +++++++----------- .../scientificcalculator/DisplayFeature.java | 17 +++-- .../scientificcalculator/MainApplication.java | 1 - .../scientificcalculator/CoreFeatures.class | Bin 2939 -> 3011 bytes .../MainApplication.class | Bin 683 -> 658 bytes 6 files changed, 42 insertions(+), 50 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 1a44927..76722cb 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -1,5 +1,8 @@ package com.zipcodewilmington.scientificcalculator; +import javax.swing.*; +import java.awt.*; +import java.awt.event.WindowEvent; import java.util.Scanner; /** @@ -9,6 +12,8 @@ public class Console { public double result; + + public double add(double num1, double num2) { result = num1 + num2; return result; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java index 25cc694..df173e0 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java @@ -1,5 +1,6 @@ package com.zipcodewilmington.scientificcalculator; +import java.awt.event.WindowEvent; import java.util.Scanner; import java.awt.DisplayMode; import java.awt.GraphicsDevice; @@ -9,43 +10,32 @@ public class CoreFeatures { - //A state, representing the value currently displayed on the calculator (default 0) - //Get current number on display - //Clear display - //Change number on display - //Calculate the square (x2) and square root (√x) of the number on the display - //Create a calculator that can perform addition, subtraction, multiplication, division - //Calculate variable exponentiation (xy) - //Calculate the inverse of the number on the display (1/x) - //Invert the sign of the number on the display (switch between positive and negative) - //Update the display to Err if an error occurs (eg: Division by zero) - //Errors must be cleared before any other operation can take place - //Each operation should automatically update the display - - public double firstNumber; - public double secondNumber; - public double answer; - private static int displayMode; - public static void setDisplayMode(int givenDisplayMode) { - displayMode = givenDisplayMode; - } + //A state, representing the value currently displayed on the calculator (default 0) + //Get current number on display + //Clear display + //Change number on display + //Calculate the square (x2) and square root (√x) of the number on the display + //Create a calculator that can perform addition, subtraction, multiplication, division + //Calculate variable exponentiation (xy) + //Calculate the inverse of the number on the display (1/x) + //Invert the sign of the number on the display (switch between positive and negative) + //Update the display to Err if an error occurs (eg: Division by zero) + //Errors must be cleared before any other operation can take place + //Each operation should automatically update the display - public static void setDisMode() { - JFrame frame = new JFrame(); - frame.setSize(800, 600); - frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); - GraphicsDevice graphics = GraphicsEnvironment.getLocalGraphicsEnvironment() - .getDefaultScreenDevice(); - graphics.setDisplayMode(new DisplayMode(800, 600, 32, 60)); - frame.setVisible(true); - } + private static int displayMode; + public static void setDisplayMode(int givenDisplayMode) { + displayMode = givenDisplayMode; + } + public static void main(String args[]) { - public void calc(){ - answer = 0; + double firstNumber; + double secondNumber; + double answer = 0; String operator; Scanner Calculator = new Scanner(System.in); @@ -63,20 +53,16 @@ public void calc(){ switch (operator) { case "+": - Console sum = new Console(); - answer = Double.parseDouble(String.valueOf(sum.add(firstNumber, secondNumber))); + answer = firstNumber + secondNumber; break; case "-": - Console sub = new Console(); - answer = Double.parseDouble(String.valueOf(sub.subtraction(firstNumber, secondNumber))); + answer = firstNumber - secondNumber; break; case "/": - Console div = new Console(); - answer = Double.parseDouble(String.valueOf(div.division(firstNumber, secondNumber))); + answer = firstNumber / secondNumber; break; case "*": - Console multiply = new Console(); - answer = Double.parseDouble(String.valueOf(multiply.multiplication(firstNumber, secondNumber))); + answer = firstNumber * secondNumber; break; default: System.out.println("Incorrect operator"); @@ -84,8 +70,5 @@ public void calc(){ } System.out.println(answer); - - } - } - +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java index 6e7e742..db9027e 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java @@ -1,21 +1,26 @@ package com.zipcodewilmington.scientificcalculator; +import javax.swing.*; import java.awt.*; import java.awt.DisplayMode; import java.awt.GraphicsEnvironment; import java.awt.GraphicsDevice; +import java.awt.event.WindowEvent; import java.awt.geom.AffineTransform; import java.awt.image.ColorModel; public class DisplayFeature { - - - - public static void main(String[] args) { - - + public static void setDisMode() { + JFrame frame = new JFrame(); + frame.setSize(800, 600); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + GraphicsDevice graphics = GraphicsEnvironment.getLocalGraphicsEnvironment() + .getDefaultScreenDevice(); + graphics.setDisplayMode(new DisplayMode(800, 600, 32, 60)); + frame.setVisible(true); + frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_STATE_CHANGED)); } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index fe4c476..3e5caa7 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -30,7 +30,6 @@ public static void main(String[] args) { CoreFeatures x = new CoreFeatures(); // x.calc(); - x.setDisMode(); // ScientificFeatures x = new ScientificFeatures(); diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class index 82ecbf6b642e67f2fd0dc8bbd31bc498ee0ed0c3..85410ee78784f8eae7db474b663cb39cd893f181 100644 GIT binary patch delta 1538 zcmY*Z+fy556#sp>uuHNH5C>xD2$?`3S(>Imp*A2TCA826S}3FhP#cn9Lm|Or11f6j z{aS5ZZ@qY}ikE7I+JuoAUwm-J@x_NeI^!SUjN@A!9rb)0Yieflo%1{UJGbwg-9Ku+ zwVA&E>+5d-^k99>bb;vwG^l?vyVHqn5{zhK5L|=wbB9cD!7V_R(1Ps@HuW^Ksja%! z+zts|>|`)y;z}ryNzBa084RvTcSt}RL+xB-DdLSRE8h50JgIn(C6ck!azEEiXvHp` zrh}o{75tA_q;zRXw_vw~JF$mhODvIDj406)nlD35(c_R7+kb3KGk3W|c#?$5SW1oON2?6x01znrig9E�rfZC9ikrx zB^*Lft(|!J6-+0hJc6fAp+Jqw*5ily@D8|%ry^n>|GkP1vn2-?0q9Zsl!-@E$ykwZ z!W>Qtn3u4Cq`GWqs#v6^TDUnaAp=FdY-q4AkJC*c$xW6(!pF$SY65O4>0uqPxuiKkS*vC;eto)z$%gy->sx@hdmt>CnTm$;KT zlbuo0k*JbLC3&zj63%kF7)vbC0u+s^gjc!IvXGru5{vVRXoT}cyv|@9Oh!}bbUdm! zQj76)L`kLjO}@#m@f=^CfICE@FBPLzst6{M@!{-Mx$F|VjV_Y5mGK+WBu!cUS*XsP zC*&nNBWaWiU~8o4aDmP;&1k|!(xoB+Z{cl1<+RE+vT)~ilA3evRR|?#69ob4VSwX* z0p6idJixnJ`12fGgrJcJ)Kg-8ZWGRMmEKXMo2YbDb{Ei?N3(3m!y|8^H7r-*#{$~( z=q#mbqHsV1ZEqv2*hZB#p%%@kqZh9oZh8r19H5GMA2pOoL@(aM`-JM~$t8TCb?{-a zph@aJOe%$BCuPeu_%_iKUPo^M`-j#sXdTMqFqh*bEUe4 zu&&eK$s?gA%U!LhJnlb-c73N|6&{Z@tHDMChjkw7vIeV-99DR&4-!RUtH}Lodo~8;{p=_c^DUC@RI1%673t zd1WJ4%4Fv4y;i&fqWJQ7gHJ-QZOkm}q_^=86DqMAw_^{D-$!%k#!gzi4(z3~7ya0W zALzSrowQ%DAHQM%H!#R5aFAIMWLq)B+Az#IaD??>gyqID$|f+zj$?w&VNx6A0Ikh+ z8uUk4rGz&~`Xfa{_wkq_wtKEap0ArPJyBozgLUNmL!y{sA=|NH_oh delta 1450 zcmY*ZX;52L6#j0u_eh>0LGJ!%8NYhZDvMLfb@`S zvudsThWkvb1g6aNkN+IUfBo-oN5@~zRGm@JeJQ49Cik50-0z-q?m6e(@2dZ*vVQ;f z#Y+JC@YQ+iId+{D^=J^VTS6n6w4c~bq3g4Tft;T|} zH8ohYb^E3T_-IFS7%FS6@S<6Q87&NgcbI;@Y3_TEgdp~6f3lFJRl+{BX(2;pcNs)< zNZ5~C7%VX*yC!ECSXe+8LxmnErzTUuiFiy=AIGB6eCpBy_fH)q8mLT8N1lH_M@?yd`w7~ z#FX}{vATLj!Yoh5wvfzZ)zRGYyqpnnr?$(~M#MP@cj0br#^mlhMi(AbR5|0$%JH<4 za4S03$8R(*A$PFVsiN;aL6tyqPTFAqp~5DzgJV~GTV*&7b~!ra{>67o2y<;@MY$MCp- zCnP+Hr?jul-N#q)jD%{cg=l%!)(cK z-$45|I-?iRy@~#j3kW-h3b=#I!zBGJ1svJHG{;fG1dm2IxTmxkYaTUpm;wbPv_hFT zv{*puEcO{YOzQ{)oGUtPFmYHLaAtIPgPFtffKw%?m0O$gtIHjNP5)Q{ z_iy3hEj&sYu0!2Mkz(ol5#|ISf3TYpb zW}(A1_=q%tj@IB~(nK2erK{uF&N}c3)~VqRb`+oDGa87`_3^R&0~KZgq5xSyC#^K% XcDvnH>v4EIoq_Q*cF)~<9wAY^O&d9&_+q zF9Q=$B?FLTWME}r1Csoc`IyA&1%P589s>gpgCLj$u~`{}7=(c|CxZxsC`c`k?FG~e zGJ|h71AF9l22LOC@Er_X8-XHB3?NhZ7?^>i90Lb~A_FgjI@mNZhzebN9O{1yoS delta 242 zcmbQlx|)^i)W2Q(7#JAr8005%)he+hC*~w`F|af6@i6c+urV@l6{nWCWET78r=+qo z2r@EQO|;jZY{tmH@sb2%y#NCfP%8tFWMp7vU;~muK%PF3W(3l#TH6^IH-e>wfh0(p zfq{oX1WbYzFo-gU0ePGZ;tUc{%|SrJK!ytKW?+xp&cNxTy^VoOJA4NNFTx}t1{R=?iVT7b>R@BVAX*tD8Ki&;I2gDXq#0zuu8{@unHb~%%_$mh From c56182b3691d8d92c4b9f49a10d8211fd8031c98 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 09:20:36 -0400 Subject: [PATCH 15/46] Working on the display mode change no GUI --- .../scientificcalculator/DisplayFeature.java | 4 +++- .../scientificcalculator/MainApplication.java | 17 +++++++++++++++++ .../scientificcalculator/Console.class | Bin 2831 -> 2831 bytes .../scientificcalculator/CoreFeatures.class | Bin 3011 -> 1749 bytes .../scientificcalculator/DisplayFeature.class | Bin 471 -> 1218 bytes .../MainApplication.class | Bin 658 -> 814 bytes .../CoreFeaturesTest.java | 17 +++++++++++++++++ 7 files changed, 37 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java index db9027e..22d43c0 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java @@ -21,7 +21,9 @@ public static void setDisMode() { graphics.setDisplayMode(new DisplayMode(800, 600, 32, 60)); frame.setVisible(true); frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_STATE_CHANGED)); - } + frame.getLayout(); + + } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 3e5caa7..9fd641b 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -3,6 +3,7 @@ import com.sun.tools.javac.Main; import java.awt.*; +import java.util.Scanner; import static java.lang.Math.E; @@ -30,6 +31,22 @@ public static void main(String[] args) { CoreFeatures x = new CoreFeatures(); // x.calc(); +// DisplayFeature y = new DisplayFeature(); +// y.setDisMode(); + + Scanner input = new Scanner(System.in); + System.out.println("Please enter the backspace (!) key to enter radian/degree mode: "); + String userInput = input.nextLine(); + + if(userInput.equals("!")) { + System.out.println("Yes"); + } + + + + + + // ScientificFeatures x = new ScientificFeatures(); diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index bfb108da0f0d4878dbe74fcb8fd80c5ba4e140d5..6af5265856beac022547aebcf05b79652a23398e 100644 GIT binary patch delta 151 zcmeAd>lfRQ#>U7!Ii1aUG8?Y7FcQ z>XYR;{8+UaI2d#$7jgKr8ZdA&7*0OMkt}Emlr>}EWw2n7V6bA4Ww4oS#Tm-#0F-x} wJcZMT)s=yZ!EN$W&S+jw25tr~24Mzoph};~zFfYH0h4EQSu%!9zRG0<0K#V>lfRQ#>U7oIi1a!m6w5?fp7A9w(!ZT*z_iwucGIo;5hjyXEd)112=;!gD`^|P^J51UoKxp@5!^dEE)YLU*)m_0NThPZU6uP diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class index 85410ee78784f8eae7db474b663cb39cd893f181..ecf54e75ba199fec4604f0926eb61e3f5f2d3f9e 100644 GIT binary patch delta 1069 zcmZuw&upP^-%4JzW|9_kuVaK+5knVu{}I3(tnc)1N4meTu37m_ufCCAsalR>yHRwZTSbq7UTpFI?AWcv(QhD( z0Y9${Xg_ezb;OB=R;GG>-EjQfM3DW;h)uoHRzOemG!C9vg?;g09eXgPV%k6fANqGgnZ%5M7?vnSp|P^LCeT%@U$dS6?p(3z zjzIs|xuu|q8?l!&S!J$}QNx+Z??RM7R+9H3A$ca-oK7CF3fFpD`(lKsXC zR+%J?=Qz#g2zvg6Gh8WrU*Qw3!c6f9XYnaimhlJ9p#lw`1yQko;6YPyUQu|V_Na(c WGe@E?kuZi;K7TVx-~zonaPeONNWp^u literal 3011 zcmb7GYf~H78Ga53?IP9~6k{8l5XEsEv<_Bc2V5JMm>{rmgt09f8=E#+mK7|Pc9q=~ z_|i7LCh7f>^pZAh(o5nby~b^Xr_A&Rbo!+q@-I5muj!Yz&)Job=wv$MojH4M?|a_o zyytn}bN>48KmP^5DDEWCf>s4F4Q+@EbgdYxMy6;uOPQI470V0+;>T^r4n_r92hy|c zP|>a+p`insz!B3eWp3JK(_OUI>|)7wmIBww_@-?+fnBgo(1*1|7#*40R&6F+A2yE98hz*3Yz35Z0N5lPiK;Zsxv&LGG zIq4bYW!v;8oK@R%of6Rt>{+scoXZ`2>}+Zvo%?_KBMJ24K@BN9B(Rf9)qv$q&$67X zwQ8H(!=8^@C7K*j@UXy+O&i&U!xGqwN92j^r$6Y0$PWWZE6_C@z+(ctHudW0>n1y; zlNxIY^bRyO(ljv=`SzfO3?3IqP;J)s?S&#?#|EyXXB8Y0=-aeotDwr^!YnGEzIcBN{$|qXOF`A&kIW4t43WCXKO67s63Ok^~&la2%f`GY!XI zvpmu#tKcbt?hs2Qu#1_zX*iDMwPOrVD;U?1#l#kN=WqCdRT5~iNsgY#0k)f&a>|t; zA9$8g;sK80q{M%U%&MXJ9}$UX45u|bgB%0It&ld2#m;)RQ(sKQ8G+9E`SG#b_{H4V zg_-m7^9h{AIR)o6XL|MZSMkg^cNazq1vkaUGC$PL!!S?(h zEF6 zy;R_)D!!E}$mX)`r|N;t;F6XM4GSwgd3YuQ6?P@NIg%34`PX1&sU5hQ_dFu zMcHj6eMQA8H3n5&XO&TLla;REGXjV1DY-emTV%GnC9~BnyrALp_yQ?mEH27SmCdHJ z64aM8d>LQisjeEuiZxS^sIs+0((J1QUc$=?zN+DC`1+QO*N?HIYBjcTcWv z+#@4&&63Sz)0DTORK>C z-HK;gleWy&-OU&8L78Ll5aX?d_kRpR<^Z;Y48E{tW@Vj__j^r(4+GBsn7s^Z!MaUf zhj^cj7W{;NIW1LQ=U?zkyEr1153>%H`~C=}p)4ODz=On++OohKq5XEe zxoQ1%D531B4Q!iR$M$FR?$%Uy%jGJ%^mr9J?qYWp{ka1h*gF@^bfvnEuVY^okLs~1 z2K5a*F{gLq@9Q{R#c%_|egXv^rdRgyk?{y2??)dVMLz}zJIxD9$4PEQZg3|ts5pV2 z;}`7pbLN-$Rk*dc>PTDW*y4)fn%?;Vj%{Fc?ha0@V{-ZqrjpZD%*gs8YyGh*E`5Nj zvj1uJ*?lf2JBy9U!htg_!?D3C?DuF8&$8$&8J0ZDeik`4RI9UtNwpkzXsz11u+4OqLfnaEo65?6Eez zw@v>OuCf%W_}pE5@h)EEHg6-Si^TQbcthkHO(N&&B8uLtG(^7LByzAWqUybBL*#o+ zA|292-;exAiDOm#P#$J$$i@QSUBDsv?m!ogU^kAETE}>l$MHDHJ%p$DKYljvrtV_^ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class index 0d9546019334eb4b6529dca46d42fb3c0b9ca269..aeb026c1317164fa73575609e3da7bc6cd369f50 100644 GIT binary patch literal 1218 zcmbVL+fvg&82*-)rqlp!IUhvuSb`E24`2~R+A?U73z#C_En$IW(u7G;D!h*m;7xI4 z#s~1u7jpbJEp3@$yfB&BWcNRP|M%_x>(7s$0G3clpaT&NQ5~I#F(i-p2{&!-9GDxs zN5TpiVvEv|!4g9xGhNaUXGkljFQ#9WxnOR$# zE-72DjwDhH!(_{eeO|GH72Ea2#MJ<;(La}3>kgoy{%VHiu4wM8s%Z-u7~NY8b=z)OZMB@jP#Dw->uJE>aNJBcj9wqKcwQn3ogG1>vWQ+e@F$RNNV2r`S2 LK?tapi9r|u{DdIZ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index 7659b6c5d647eb124777def34de91d4cc774a089..897b9444924ddb6560fbd4a10a78a72f6a5777fa 100644 GIT binary patch delta 308 zcmY+8y-EX75QV>+xObE5x>=*fe@#-wAJ9rr!8Br()M97AEd)VLVv)*cSo0o&Rm6aW zrKPW8FP>cmu{p!cob$~*c#qb-f4#f{N7NE`YkejS`$=ZZrkQ~`D(Z^Nv+x@}7c8$?WsH9|qSzYaRD<^R=`&M*v@#PkVT}Sc hBI-hIWa#QooJE#|DG;*Eir|qRSd~BhbzPer)oq_Q*cF)~<9 zY}B4y#mGNdjPdhiZzk1xUIr$hP6i;!$iT|L1|<1`JbfU|2&7rHwlgqp1WOA5Nsu%H z&|pC@30A-$#2^ghaWaT7h(a}c0SyBg%D0<=J#sq(r;m2{4hAlSDSQmfKv_8k4hBUA hO Date: Sun, 26 Jun 2022 09:28:29 -0400 Subject: [PATCH 16/46] Added scanner to MainApplication to test switch --- .../scientificcalculator/MainApplication.java | 5 ++++- .../scientificcalculator/MainApplication.class | Bin 814 -> 1314 bytes 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 9fd641b..e187a92 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -34,12 +34,15 @@ public static void main(String[] args) { // DisplayFeature y = new DisplayFeature(); // y.setDisMode(); + Scanner input = new Scanner(System.in); - System.out.println("Please enter the backspace (!) key to enter radian/degree mode: "); + System.out.println("Please enter an exclamation (!) key to switch to degree mode or a hashtag (#) to switch to radian mode:"); String userInput = input.nextLine(); if(userInput.equals("!")) { System.out.println("Yes"); + } else if (userInput.equals("#")) { + System.out.println("NO"); } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index 897b9444924ddb6560fbd4a10a78a72f6a5777fa..4df7de48c21b4df7d67e2621afe04902726a709b 100644 GIT binary patch literal 1314 zcmbVLTTc@~6#k}Mwk$=U1w`?(6@e}S>jgz9qKIHj$|b33f<6t)SO&Jcb$3?4f8sCj zSsoyf#24TEQN%MXgp0gjH<{_2bLM>K`{tZKM?Zf7n88~U2{agJOrZ(Q3>};N3wJ#3 zm!0LcP2nnr=4t6mHN()5vr7h&3=?ipalXo`8?1|M=~bj(R)OzCt`xqKpQP(@&y78< zg3y@@La`vYibD~ZFf>*xLuU;pR?>5dF86&AwxA8y478`vfzESv6n7&fDhvtfGjtbf zH)Y_w^Q*Bcs!;Gs-h_#aX3)jZo4Yi`E@_0G6t1I}s01-FJ59C{O8+ET5;qyjE1uwy zu!xWdE$&-l$MtxHD;fA!E^Av`V%JiE6>Ur9Zs>pOq8tigRY(&npexn}k2Vx9Te*Jw zd}PSiC1uo+QzmZVwt+h-+=a!EIbnCEAO@qV%kwn-V{)|zBJ!ks-Y#kS_fqJ`eTJkj zc2q(7f}tyC*QGccox~sm%bLi+HZYvR1B{%PyOx!nU3`wY7hS-tH$~q5ki;0txGJI~ z9#X>oBp%ZfEiD@uXPCM|gDi6C&sM9RbZg==G|rJQ4DFi4Qe0UR;d{R3ktJOSsIf{s zl=^&ZY*ZVPikvR|KV+UTD^vwTPwwNtirFRd^RP@PnM>S6eurW5D)?t-g20=kZe_|| z$38n1GTIAJZMa*Ilhpt$VTC=VT@{Z{Q$l?i&z5XRY z_-Ll}DV-eJ8SPEO2Vg&H?q{@WH)wh$Xie1v@EntLYQYrpWYL#@qXCVyFC4;HJwQw0 z5a#M0QU^#c?x8z~T7+4tW85rakI2aTe1Q?WnMrneLR)A<{kYtbo d8pFZB#~{rh12kL!=m1%udXQV?fig@C3II3zDJ%d0 From 40c4562bf2a3372b09d9f1dfde2826ce59350d14 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 10:30:48 -0400 Subject: [PATCH 17/46] Added the program for the switch to degrees and radians --- .../scientificcalculator/MainApplication.java | 31 ++++++++++---- .../ScientificFeatures.java | 40 ++++++++++++++++++ .../MainApplication.class | Bin 1314 -> 835 bytes .../ScientificFeatures.class | Bin 2505 -> 3850 bytes 4 files changed, 63 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index e187a92..311b951 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -29,21 +29,36 @@ public static void main(String[] args) { // CoreFeatures x = new CoreFeatures(); + + // x.calc(); // DisplayFeature y = new DisplayFeature(); // y.setDisMode(); + ScientificFeatures radToDegree = new ScientificFeatures(); + radToDegree.radianOrDegree(); + - Scanner input = new Scanner(System.in); - System.out.println("Please enter an exclamation (!) key to switch to degree mode or a hashtag (#) to switch to radian mode:"); - String userInput = input.nextLine(); - if(userInput.equals("!")) { - System.out.println("Yes"); - } else if (userInput.equals("#")) { - System.out.println("NO"); - } +// Scanner input = new Scanner(System.in); +// System.out.println("Please enter an exclamation (!) key to switch to degree mode or a hashtag (#) to switch to radian mode:"); +// String userInput = input.nextLine(); +// +// switch (userInput) { +// case "!": System.out.println("Yes"); +// +// break; +// case "#": System.out.println("NO"); +// break; +// default: +// break; +// } +// if(userInput.equals("!")) { +// System.out.println("Yes"); +// } else if (userInput.equals("#")) { +// System.out.println("NO"); +// } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 233ff87..9255b90 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -1,7 +1,11 @@ package com.zipcodewilmington.scientificcalculator; +import java.util.Scanner; + public class ScientificFeatures { double result; + double toRadian; + double toDegree; @@ -98,5 +102,41 @@ public double inverseLn(double num1){ return result; } + public double radianNum (double num) { + toRadian = Math.toRadians(num); + return toRadian; + } + + public double degreesNum(double num){ + toDegree = Math.toDegrees(num); + return toDegree; + } + + public void radianOrDegree() { + + ScientificFeatures Degree = new ScientificFeatures(); + ScientificFeatures Radian = new ScientificFeatures(); + + Scanner input = new Scanner(System.in); + + System.out.println("Please enter an exclamation (!) key to switch to degree mode or a hashtag (#) to switch to radian mode:"); + String userInput = input.nextLine(); + + + switch (userInput) { + case "!": System.out.println("Degree"); + System.out.println("Please enter your number: "); + double userInputNum = input.nextDouble(); + System.out.println(Degree.degreesNum(userInputNum)); + break; + case "#": System.out.println("Radians"); + System.out.println("Please enter your number:"); + double userInputRad = input.nextDouble(); + System.out.println(Radian.radianNum(userInputRad)); + break; + default: + break; + } + } } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index 4df7de48c21b4df7d67e2621afe04902726a709b..57ea37666d1b479becba84a48611aa1e30001c16 100644 GIT binary patch delta 319 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 qy{VDix@Sj{F Date: Sun, 26 Jun 2022 10:32:43 -0400 Subject: [PATCH 18/46] Deleted some comments --- .../scientificcalculator/MainApplication.java | 27 ------------------- 1 file changed, 27 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 311b951..5b2e3fd 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -31,44 +31,17 @@ public static void main(String[] args) { CoreFeatures x = new CoreFeatures(); - // x.calc(); - -// DisplayFeature y = new DisplayFeature(); -// y.setDisMode(); ScientificFeatures radToDegree = new ScientificFeatures(); radToDegree.radianOrDegree(); -// Scanner input = new Scanner(System.in); -// System.out.println("Please enter an exclamation (!) key to switch to degree mode or a hashtag (#) to switch to radian mode:"); -// String userInput = input.nextLine(); -// -// switch (userInput) { -// case "!": System.out.println("Yes"); -// -// break; -// case "#": System.out.println("NO"); -// break; -// default: -// break; -// } -// if(userInput.equals("!")) { -// System.out.println("Yes"); -// } else if (userInput.equals("#")) { -// System.out.println("NO"); -// } - - -// ScientificFeatures x = new ScientificFeatures(); -// double y = x.factorial(5); -// System.out.println(y); } } From 51335f8e2b59a4091b2abcbb56e3c22998e3805b Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 10:40:17 -0400 Subject: [PATCH 19/46] Finished the switch statement in ScientificFeatures --- .../ScientificFeatures.java | 2 +- .../MainApplication.class | Bin 835 -> 835 bytes .../ScientificFeatures.class | Bin 3850 -> 3882 bytes .../CoreFeaturesTest.java | 3 +++ 4 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 9255b90..412c916 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -125,7 +125,7 @@ public void radianOrDegree() { switch (userInput) { case "!": System.out.println("Degree"); - System.out.println("Please enter your number: "); + System.out.println("Please enter your number with a decimal point value only: "); double userInputNum = input.nextDouble(); System.out.println(Degree.degreesNum(userInputNum)); break; diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index 57ea37666d1b479becba84a48611aa1e30001c16..74cf9cb758bdf45f6ca14c5a29644ce6655a4bb2 100644 GIT binary patch delta 21 ccmX@ic9?Ag7c-|ag8+jHg9wA(WMO6l05nts%K!iX delta 21 ccmX@ic9?Ag7c-|Sg8+jXg9wBBWMO6l05tsr=l}o! diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class index f39a886ba059ab43bae058ebd1ea0b3300293374..7d21d0663381b157036933fa72611c0c26a35086 100644 GIT binary patch delta 51 zcmeB@TP3$amW9!3@&pzM1%>j=k_?4Jg_P9f%-qBrg@XLdyb^`7#GKMph5Wpn%FSjh GSGWMG<`G-~ delta 18 ZcmZ1_*Cn?>mW5Gj@&*>k&EYJUxd1k@1*iZ3 diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java index 5de5241..265f5b2 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java @@ -30,5 +30,8 @@ void calc() { // Division + // Divide by zero + + } \ No newline at end of file From 1841def5f9e88e2cc0cbd5d183bc3f28e41c3281 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 10:54:26 -0400 Subject: [PATCH 20/46] Messing with the test --- .../scientificcalculator/MainApplication.java | 2 ++ .../ScientificFeatures.java | 7 +------ .../MainApplication.class | Bin 835 -> 1017 bytes .../ScientificFeatures.class | Bin 3882 -> 3810 bytes .../CoreFeaturesTest.class | Bin 0 -> 580 bytes .../ScientificFeaturesTest.class | Bin 3684 -> 3662 bytes .../CoreFeaturesTest.java | 1 + .../ScientificFeaturesTest.java | 9 +++++++-- 8 files changed, 11 insertions(+), 8 deletions(-) create mode 100644 src/out/test/test/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.class diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5b2e3fd..758fd90 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) { CoreFeatures x = new CoreFeatures(); + ScientificFeatures y = new ScientificFeatures(); + System.out.println(y.inverse(0)); ScientificFeatures radToDegree = new ScientificFeatures(); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 412c916..670bdd1 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -27,12 +27,7 @@ public double switchSign(double num1) { public double inverse(double num1) { result = 1 / num1; - if (num1 == 0) { - // Should be error - System.out.println("You cannot divide by 0"); - } else { - return result; - } + return result; } public double sine(double num1) { diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index 74cf9cb758bdf45f6ca14c5a29644ce6655a4bb2..cf59e70b38c8c6ae4bab3ab5b058cbc9dab1f921 100644 GIT binary patch delta 447 zcmZvYO)mpc6o#KW{TLn78sD@&O3|t^Wh=4jvOW?bv62ZB8DT2Z(ZtHe9}vHUMTI6d zcK(H*VIxjE5*xY6d+t5&dEYnZz9+wQE>SmQcWjMjUM*Rb~j&ky&*z;!M+4Gcz1Mj2D+p5JnVrmKjTYRff)2_|*2 zCOM`Q!~e)dQ@QH8UHFmcuaj-`1iLh(Sr9a%0Tx-3SBfGf>2$?+#N|M# zgMRc(s@}nnYHmM~u4LK_w;BI!?VPN(nf?pNN(8b;A9Gk@mJ|De1QeB-WB&TV+kQD99GJ++xzL%8bVP5AGyNfB*mh delta 266 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 IZTS6v0VJE>EC2ui diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.class new file mode 100644 index 0000000000000000000000000000000000000000..fa92b542a3ee382f92330aedb116b6a9d10ac30c GIT binary patch literal 580 zcmbtR%T59@6g?eAP(Z-f!o-D3ABp_{l*C|IjhZN7U&e};%(SG_(db{fGI8Mt_)*4N zWnpx|!X~}9_i@gB^!?-Y4L}c@bwsGt5I3=esz7I|?v>1xnaIoWRHt5`dQ66VPoT25 zKdNC_pqtuUKG7_-H~N9HoXo^qBa4)@@pMaRscgFsX3W1a4A2quItwQ@VDrT8_JpU@ceN}R=xgJqL zTy;;KxY$l&-9%1H9-HNiymnH}NQVBID-Poc)UR#nQazy1`_}I{kHR9ciyH4Y zoC;swFa%ckC0UE$Ie3A1=0}7&%Mb=b8Z4XN39MJy0$Lo6zQBiUg}gt&#t)#F1KXS! UXgjQdwZ$Zz1tk1WOcY_`6HB>!YXATM literal 0 HcmV?d00001 diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class index cbbd412d17647b7d37cc20751a67144683902ef3..4824b49f8add1fe9c536c044d8b6ea9e2bcbc46e 100644 GIT binary patch literal 3662 zcmbuBU2GIp6vxlB+u3#*+NCYDrGTI!EeNX=RD^bS?b1+LD0WMsD&TZFZKrN$%FZlR zz68I&z)w_EG|G#Qn3zH|F~mn7jEM;^M#GbD#`xk#jK=?+xidR~yDbUZWcHqO&$+*I z?m1_+-~RXI*F@AsAIGSIDx(xpsETBX;uGp2HIY}%u|(hSgswRf$y*H5aJnR_Y-=Bk zQnf^#nl+g?Y)om^h(2xPCk=DVvCM?68M^5hqlTubd99dN9jlPY1>b&3Vuj!~2< zXl;P-w zggRv;(zdM^9K$kgi4@fpw&J)v#HzMTrhSl+S`=E$NHLGpZ&?mgFHvZzr=B((Z9Hd; znet^Gpqz^PVMOURg>GktQNui>7i?Wle(!HKP#X)d9cci^d21B9li5dX!-Vln-<3<> zoUCBTyA-;c?Nn-(Ehm4w`okB^3qNHW8x^|8-EdSB9{Oh+&h5S`r+Ph(oORGYV~GhV!{$x8=q2`{Q3; zD2+*!zNtPO&~0>gq#I2vQC${yx3f4otQQ8<;XE|;Sqp7Es3J|sTp4l34K!4D_NK|3 zaUCpz9B+BvkzP>An>!z8N4*9gkVwi%)Y4zXU{30ThHW63v}sz7%4cOsRyKRnI zOJvAIG&1fHBNS{$xxfw3##mvLJm&~oq1sI10pwgj9mg`sGgZPGi57%hyzzmKn|QM4 z=Fbn;p^rk2e5j!0o?PL%`Z4%Q%q!dI@rMm^FnFFvtR(Y%FXdgi^j$`kuxhhK10o5$3*N!II#)mHsje+hFzSMeP~uT@@@rt znTWj<>}6oz0``hB?CF60gdp!H1Ga`0yYrUNoiCrETftu0R(pw7U3=*(0lx$ARY-kZ z2;LH0`T{!4;Wczb06!YQ%M^Sy;A=&RuLrvW>d1 z0`@xs_PcYj9|ik>h;4)IfL#Q8x(xfhfPGfLet#~u3igPIeFW^IU>^hfcp3Hw0sF)2 N*b<$?Xjjlj{{#6Y$&Ua4 literal 3684 zcmbu>TTC2P7zglgV3~#O6eyPh(pJ3GLKRjEHrN8YxC=_Vw3gjcDcW|J4$I&&v)!46 zUc9vRexY8g*2{zT#mAZ$+Gt`LAAK+;CVerQKKW*hFJ59a{?E+p?8csfnnJS7Ip;g) z_nn#Z&GPj>pMOb21N1?N%BVa@0f{O|6lj}b%!Q9@S;aW4E@+uKO;1~f9yS$C)h%sW zQxrL)bU>8;~h}SZlRJ)l>t?Jd&4lsz8DEct>1}-d6~zr-mRkO0<@m1Zp#K>F{hGIpH&_ zS!ymUXSML4X{tGvu_=%w+l?VCmqD|lJs$5EXHttqH!&&XNMnX!vF>#et#`T?G)tLD zYH3}(>?SBiYYS-v={AXOXMsUYpI39HDn`C74z^3w!3G1SrekDj_mxXuohoDNcS_X7 zM#>e#6eGV}{qD2o#*f*+7Kys;0ZY~~L;a-Z!@XC<=!mnZ7@a(6U$M~b67^BPK&xCj z3B=u6T#Wp<<*&c5be?B{gA(1(0$00%F~iB{*Ry@8Z$7%fLWU)JfQ3}MAt_l;<0OcY z??-=_K7S(0Vs=WDV5wD2%L>kgCTGOxf#PN#l4y^edB#YKk)Iy@ZQq5Mz~=3hXq*j% z+_e)JkNz?1?PI@0lWe>!gB|~QdGPn27rWWKgAyIGy}~?Qj7}}~p38Qh3DRMK25;!l zrBu_xlZl}K1gc5k-tEfIO{uw*Je5IDUBW;KjLX<2+HPmSn$d82Vu>4;x8ruO43h5o zc8{NvROH6i$J#;XG^Yd-;sUjdbPcV*vz1=8mt0--PW%E%qncRq#uthY2Z+Mhd>X*bjT};_Hh9QgIc=UxD>(zDUBSxG1A(e6nGpDoW#1 zasp_EG_;6jF<%A$!LyHY>|@K? z*!L#bn|XF8>@L`0*mwKb$36Q5$9{Yz`!3jFp4|icUf5e<_xjjRc=nSV`>B=edtmqQ z>^|82um@mAeC(5+eTrkB_G}f!%4)2&q{g;3Q123L13$pyW8mXdPeb^xY`BDP^~$WC zp0@dVL_WjepS=z~3O>f;cVN+-;1l3SefZ}*{&^1n!gcUN;2-4id%%x@Pl8YR@GpA& zOC0`XkN0`O?SMVXvmb^%fd{`I4}P-5E`7nh;yw69j(uh&dpGPco_!GZA=ol(#m9ct zvtQ%budigMVDIDEY1lKcHQ2L0_8Xr4CdYnjC3^z)BRpG&ZNSdL&iUA9J^O8r{mx4E f0oXFno`<~v`zY*VKK8qweeN1tp!ZPPW%T~PCU?~p diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java index 265f5b2..87a5e7e 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java @@ -34,4 +34,5 @@ void calc() { + } \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java index f8dd020..ea41bce 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java @@ -35,9 +35,14 @@ void TestSwitchSign() { @Test void TestInverse() { ScientificFeatures inverseTest = new ScientificFeatures(); - double inverseT = inverseTest.inverse(4); + double inverseT = inverseTest.inverse(0); Assertions.assertEquals(0.25,inverseT); - //Come back to this + // Need to understand this +// Throwable exception = assertThrows(IllegalArgumentException.class, () -> { +// inverseTest.inverse(0); +// }); +// assertEquals("Error", exception.getMessage()); +// //Come back to this } @Test From 41944250ef509d73e2fc9b07bdfdf3049932d00b Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 10:56:17 -0400 Subject: [PATCH 21/46] Accidently deleted a code --- .../scientificcalculator/ScientificFeatures.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 670bdd1..eb119b3 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -27,8 +27,14 @@ public double switchSign(double num1) { public double inverse(double num1) { result = 1 / num1; - + if (num1 == 0) { + // Should be error + System.out.println("Err"); + } else { + return result; + } return result; + } public double sine(double num1) { result = Math.sin(Math.toRadians(num1)); From 7e5319b8fbb9c2eb1b3eb1b30967115944b5ad52 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 11:59:26 -0400 Subject: [PATCH 22/46] made changes back to normal --- .../scientificcalculator/MainApplication.java | 41 +++++++++++++----- .../ScientificFeatures.java | 30 +++---------- .../MainApplication.class | Bin 1017 -> 1017 bytes .../ScientificFeatures.class | Bin 3810 -> 3863 bytes .../ScientificFeaturesTest.class | Bin 3662 -> 3751 bytes .../ScientificFeaturesTest.java | 12 ++--- 6 files changed, 38 insertions(+), 45 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 758fd90..b66398b 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -13,9 +13,6 @@ public class MainApplication { - - - public static void main(String[] args) { // Console.println("Welcome to my calculator!"); @@ -34,16 +31,36 @@ public static void main(String[] args) { System.out.println(y.inverse(0)); - ScientificFeatures radToDegree = new ScientificFeatures(); - radToDegree.radianOrDegree(); - - - - - - - + } + public void radianOrDegree() { + + ScientificFeatures Degree = new ScientificFeatures(); + ScientificFeatures Radian = new ScientificFeatures(); + + Scanner input = new Scanner(System.in); + + System.out.println("Please enter an exclamation (!) key to switch to degree mode or a hashtag (#) to switch to radian mode:"); + String userInput = input.nextLine(); + + + switch (userInput) { + case "!": + System.out.println("Degree"); + System.out.println("Please enter your number with a decimal point value only: "); + double userInputNum = input.nextDouble(); + System.out.println(Degree.degreesNum(userInputNum)); + break; + case "#": + System.out.println("Radians"); + System.out.println("Please enter your number:"); + double userInputRad = input.nextDouble(); + System.out.println(Radian.radianNum(userInputRad)); + break; + default: + break; + } } + } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index eb119b3..6ee8d26 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -4,6 +4,7 @@ public class ScientificFeatures { double result; + double toRadian; double toDegree; @@ -36,6 +37,10 @@ public double inverse(double num1) { return result; } + + + + public double sine(double num1) { result = Math.sin(Math.toRadians(num1)); return result; @@ -113,31 +118,6 @@ public double degreesNum(double num){ return toDegree; } - public void radianOrDegree() { - - ScientificFeatures Degree = new ScientificFeatures(); - ScientificFeatures Radian = new ScientificFeatures(); - Scanner input = new Scanner(System.in); - - System.out.println("Please enter an exclamation (!) key to switch to degree mode or a hashtag (#) to switch to radian mode:"); - String userInput = input.nextLine(); - - - switch (userInput) { - case "!": System.out.println("Degree"); - System.out.println("Please enter your number with a decimal point value only: "); - double userInputNum = input.nextDouble(); - System.out.println(Degree.degreesNum(userInputNum)); - break; - case "#": System.out.println("Radians"); - System.out.println("Please enter your number:"); - double userInputRad = input.nextDouble(); - System.out.println(Radian.radianNum(userInputRad)); - break; - default: - break; - } - } } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index cf59e70b38c8c6ae4bab3ab5b058cbc9dab1f921..cf924736d78f53fe0bcb2a6abf09364c9bca1cba 100644 GIT binary patch delta 21 bcmey#{*!&fHfByW24x0yAT*r3pVd*`8^;+Io+ErF7 zCk9HPg@$tP1qio5X^UrI7^Y0)WXiOB=(qMmXUc!*=YDOcQ~I3U^+ryt=0iQ&%Q@#g z&w0;tp7(v%fBw(!{|I0|R#NCdOh#NqClV66Pw7i~v8vmZ;*r@?rr}9Q+;7>Iw_idm zm!D2TK~hFa#U`i{_8CsC_?T5UoH_H1RjpZe#dGXp!>~--v*s21MyH)7XKk7E;Vh?k)U|A{?76018&PmG4Gy|)3b)`^8Jddi7?iMi z17ittT}-XoM9T$mK25~pu1E6IVgox=d`)H6KN@vxn?71T`x+5S}42`OI5D(Gix^spG zxe{3y{UsF##grJQBt|>GNWIW|!V;pGQ1P%(gtE4CVLhqhkgz5lC9~q1W}9>3R9R78a^qZKRh0u zcB@H#TEVv^RE}0nyY*RvSE`P0fQkaDyV@`#M z`SmjP)kOrc<^g&@>T~%C1&j!3yO?)M#UiQ6j@H#q{ou(TKMC1M!xY;?=uxb=h-J$xmCB51t3wCvRSQ9(+R5Y<9AtiQLa+H$mjY>lV?T_f|Fy4utYR6cLwTi4PjE1j6fvxT&sV&R;Ka{bIcO@x$)Xk zv0Eet%0^+i0%E*afBbaCtm8kKQuy2qx`G7n&#+bGQ{uC;a0$|H`O<-Bc^AX%#E*Gb z!}oJ|jx7m4K@aa@a)}mVA+?arE?$IO_#Na=*$yy7-2^gV#qx3b{I-e!N8mp1V@r4; zLOe)3f!I~ZUPf0N$X@PoOABOI1lbiqz8FD{g-)gm*mlY~A(M6JWj6iBTS$L~Ej>4_V%rK7pNTa(Vm_sPoCC(Tj9bygbLz(swy_opiUVo} zqcsP^HDBgf93A~}68=iG`gllEw;*ZgGHz?b(=IAtcME=Zgx?+QiB&c{%&SrJZBXwd z>Rs1CWvy<5dV3qxdx(1Pbx>c$Lm}!haw*u%6ta2eGKy_L_aVg(I6<)Ht11%_kikzw zU1#t!zQqXq^LFrewt+uD_);7AUt9zKT08i=+rUo{{^2(8SG*Ss3GZKzDF28Oi*wJT zg$$9i>GSUd(!AG~W{z5Y8-wxv+s zt+YUH-g0Px=u$=w?MW!`i`$+NqnPh z1o@4NI84aHS3@=lxpW=Kch^dg^a0hniHG#%=TK%Y;n-yOJoGuHW(-o!xXD)f&z6HFbV>VRn#xQW*gubl&(J(X2hZ=x@@H?e|lwrhSn z5#O8Gk`OZuUSgj38{j3X-hQ!|!^On&bg*dSKAEkZ{qic#tm3g1aGyh^&xGh8mP^$|<#Ck&X2 zER27^i}({>!e8++{>D@#lG!)|`~nN>1)h$~(G1?>TaqJRh5@JGFQ^lVAIcnmpKl#p y@iKmi59m*xEBp$-ChelW3?cCq<64%Xto^2B%<@MvGV0bH|HKXg{f4F;`0&5e=Gn6V literal 3810 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 C`Ri5y literal 3662 zcmbuBU2GIp6vxlB+u3#*+NCYDrGTI!EeNX=RD^bS?b1+LD0WMsD&TZFZKrN$%FZlR zz68I&z)w_EG|G#Qn3zH|F~mn7jEM;^M#GbD#`xk#jK=?+xidR~yDbUZWcHqO&$+*I z?m1_+-~RXI*F@AsAIGSIDx(xpsETBX;uGp2HIY}%u|(hSgswRf$y*H5aJnR_Y-=Bk zQnf^#nl+g?Y)om^h(2xPCk=DVvCM?68M^5hqlTubd99dN9jlPY1>b&3Vuj!~2< zXl;P-w zggRv;(zdM^9K$kgi4@fpw&J)v#HzMTrhSl+S`=E$NHLGpZ&?mgFHvZzr=B((Z9Hd; znet^Gpqz^PVMOURg>GktQNui>7i?Wle(!HKP#X)d9cci^d21B9li5dX!-Vln-<3<> zoUCBTyA-;c?Nn-(Ehm4w`okB^3qNHW8x^|8-EdSB9{Oh+&h5S`r+Ph(oORGYV~GhV!{$x8=q2`{Q3; zD2+*!zNtPO&~0>gq#I2vQC${yx3f4otQQ8<;XE|;Sqp7Es3J|sTp4l34K!4D_NK|3 zaUCpz9B+BvkzP>An>!z8N4*9gkVwi%)Y4zXU{30ThHW63v}sz7%4cOsRyKRnI zOJvAIG&1fHBNS{$xxfw3##mvLJm&~oq1sI10pwgj9mg`sGgZPGi57%hyzzmKn|QM4 z=Fbn;p^rk2e5j!0o?PL%`Z4%Q%q!dI@rMm^FnFFvtR(Y%FXdgi^j$`kuxhhK10o5$3*N!II#)mHsje+hFzSMeP~uT@@@rt znTWj<>}6oz0``hB?CF60gdp!H1Ga`0yYrUNoiCrETftu0R(pw7U3=*(0lx$ARY-kZ z2;LH0`T{!4;Wczb06!YQ%M^Sy;A=&RuLrvW>d1 z0`@xs_PcYj9|ik>h;4)IfL#Q8x(xfhfPGfLet#~u3igPIeFW^IU>^hfcp3Hw0sF)2 N*b<$?Xjjlj{{#6Y$&Ua4 diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java index ea41bce..90ab970 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java @@ -9,7 +9,6 @@ public class ScientificFeaturesTest { - @Test void TestSquare() { ScientificFeatures squareTest = new ScientificFeatures(); @@ -36,15 +35,12 @@ void TestSwitchSign() { void TestInverse() { ScientificFeatures inverseTest = new ScientificFeatures(); double inverseT = inverseTest.inverse(0); - Assertions.assertEquals(0.25,inverseT); - // Need to understand this -// Throwable exception = assertThrows(IllegalArgumentException.class, () -> { -// inverseTest.inverse(0); -// }); -// assertEquals("Error", exception.getMessage()); -// //Come back to this + Assertions.assertEquals("Err",inverseT); + } + + @Test void TestSine() { ScientificFeatures sineTest = new ScientificFeatures(); From 9a4947485e97e5604d4a0c027a5643aa83c3812d Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 14:01:02 -0400 Subject: [PATCH 23/46] Added changes to switch statement --- .../scientificcalculator/Console.java | 1 - .../scientificcalculator/DisplayFeature.java | 36 ------ .../scientificcalculator/DisplayWork.java | 109 ++++++++++++++++++ .../scientificcalculator/MainApplication.java | 25 +++- .../scientificcalculator/Console.class | Bin 2831 -> 2831 bytes .../scientificcalculator/DisplayFeature.class | Bin 1218 -> 0 bytes .../scientificcalculator/DisplayWork.class | Bin 0 -> 3686 bytes .../MainApplication.class | Bin 1017 -> 2215 bytes .../ScientificFeatures.class | Bin 3863 -> 2763 bytes .../TestMainApplication.class | Bin 370 -> 938 bytes .../ScientificFeaturesTest.class | Bin 3751 -> 3751 bytes .../TestMainApplication.java | 13 +++ 12 files changed, 144 insertions(+), 40 deletions(-) delete mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java delete mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayWork.class diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 76722cb..82ff99c 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -13,7 +13,6 @@ public class Console { public double result; - public double add(double num1, double num2) { result = num1 + num2; return result; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java deleted file mode 100644 index 22d43c0..0000000 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayFeature.java +++ /dev/null @@ -1,36 +0,0 @@ -package com.zipcodewilmington.scientificcalculator; - -import javax.swing.*; -import java.awt.*; -import java.awt.DisplayMode; -import java.awt.GraphicsEnvironment; -import java.awt.GraphicsDevice; -import java.awt.event.WindowEvent; -import java.awt.geom.AffineTransform; -import java.awt.image.ColorModel; - -public class DisplayFeature { - - - public static void setDisMode() { - JFrame frame = new JFrame(); - frame.setSize(800, 600); - frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); - GraphicsDevice graphics = GraphicsEnvironment.getLocalGraphicsEnvironment() - .getDefaultScreenDevice(); - graphics.setDisplayMode(new DisplayMode(800, 600, 32, 60)); - frame.setVisible(true); - frame.dispatchEvent(new WindowEvent(frame, WindowEvent.WINDOW_STATE_CHANGED)); - frame.getLayout(); - - } -} - - - - - - - - - diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java new file mode 100644 index 0000000..04f409c --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java @@ -0,0 +1,109 @@ +package com.zipcodewilmington.scientificcalculator; + +import java.util.Scanner; + +public class DisplayWork { + int loopFor; + double answer; + + + public void store() { + double firstNumber; + double secondNumber; + + String operator; + Scanner Calculator = new Scanner(System.in); + System.out.println("Please enter only these operations + - / * (square) ** */ (squareRoot) +/-(switch sign) fac (factorial) \n inverse sine cosine tan \n invsine incosine invtangent"); + + System.out.print("Enter first number "); + firstNumber = Calculator.nextDouble(); + + System.out.print("Enter math operator to use for this calculation "); + operator = Calculator.next(); + + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + + switch (operator) { + case "+": + answer = firstNumber + secondNumber; + System.out.println(answer); + break; + case "-": + answer = firstNumber - secondNumber; + break; + case "/": + answer = firstNumber / secondNumber; + break; + case "*": + answer = firstNumber * secondNumber; + break; + case "**": + ScientificFeatures squareFormula = new ScientificFeatures(); + String squareFormulaPrint = String.valueOf(squareFormula.square(firstNumber)); + System.out.println(squareFormulaPrint); + break; + case "*/": + ScientificFeatures squareRootFormula = new ScientificFeatures(); + String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); + System.out.println(squareRootFormulaPrint); + break; + case "+/-": + ScientificFeatures switchSignFormula = new ScientificFeatures(); + String switchSignFormulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); + System.out.println(switchSignFormulaRead); + break; + case "inverse": + ScientificFeatures inverseFormula = new ScientificFeatures(); + String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); + System.out.println(inverseFormulaRead); + break; + case "sine": + ScientificFeatures sineFormula = new ScientificFeatures(); + String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); + System.out.println(sineFormulaRead); + break; + case "cos": + ScientificFeatures cosineFormula = new ScientificFeatures(); + String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); + System.out.println(cosineFormulaRead); + break; + case "tan": + ScientificFeatures tanFormula = new ScientificFeatures(); + String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); + System.out.println(tanFormulaRead); + break; + case "invsine": + ScientificFeatures arcSine = new ScientificFeatures(); + String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); + System.out.println(arcSineRead); + break; + case "invcosine": + ScientificFeatures arcCosine = new ScientificFeatures(); + String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); + System.out.println(arcCosineRead); + break; + case "invtangent": + ScientificFeatures arcTan = new ScientificFeatures(); + String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); + System.out.println(arcTanFormula); + break; + case "fac": + ScientificFeatures factorialFormula = new ScientificFeatures(); + String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); + System.out.println(factorialFormulaRead); + break; + default: + System.out.println("Incorrect operator"); + break; + } + if() { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } + + + + } + +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index b66398b..6bb5b7d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -25,15 +25,34 @@ public static void main(String[] args) { // Console.println("The user input %s as a d", d); // - CoreFeatures x = new CoreFeatures(); +// CoreFeatures x = new CoreFeatures(); +// +// ScientificFeatures y = new ScientificFeatures(); +// +// System.out.println(y.inverse(0)); - ScientificFeatures y = new ScientificFeatures(); - System.out.println(y.inverse(0)); +// DisplayWork g = new DisplayWork(); +// g.store(); + MainApplication z = new MainApplication(); + z.clearScreen(); } + private int displayMode; + //clear display + String xinput = " "; + int z; + public void clearScreen() { + z = 0; + Scanner x = new Scanner(System.in); + xinput = x.nextLine(); + System.out.println("\033[H\033[2J"); + System.out.flush(); + z++; + } + public void radianOrDegree() { ScientificFeatures Degree = new ScientificFeatures(); diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index 6af5265856beac022547aebcf05b79652a23398e..a7e1a728fe4950bf0fdbf13ab307b05874ab2019 100644 GIT binary patch delta 161 zcmeAd>lfRwij7r}ft^8U@_M##Rxuz;9LUm~Y{IU`Dh=exfO!*uJOv<65zKo7N9XM7)(CKkt}Eelr?4GWiV%uV6bG6Ww4%X#Tm+K50rP9 wJcZMT)rEnJ!FBRe&S+i_25tsV24My-pi1w_zFfYH{*z~OSuzGszRG0<084EkVgLXD delta 161 zcmeAd>lfRwij7r>ft^8k@_M##R&gLp0?5*wY{IU`Dg)%nf_W2wJVhW+3Cw!~XYR;{8+UaI2d#$7jgKr8ZdA&7*0OMkt}Emlr>}EWw2n7V6bA4Ww4oS#Tm-#0F-x} wJcZMT)s=yZ!EN$W&S+jw25tr~24Mzoph};~zFfYH0h4EQSu%!9zRG0<08{!Pe*gdg diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayFeature.class deleted file mode 100644 index aeb026c1317164fa73575609e3da7bc6cd369f50..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1218 zcmbVL+fvg&82*-)rqlp!IUhvuSb`E24`2~R+A?U73z#C_En$IW(u7G;D!h*m;7xI4 z#s~1u7jpbJEp3@$yfB&BWcNRP|M%_x>(7s$0G3clpaT&NQ5~I#F(i-p2{&!-9GDxs zN5TpiVvEv|!4g9xGhNaUXGkljFQ#9WxnOR$# zE-72DjwDhH!(_{eeO|GH72Ea2#MJ<;(La}3>kgoy{%VHiu4wM8s%Z-u7~NY8b=z)OZMB@jP#Dw->uJE>aNJBcj9wqKcwQn3ogG1>vWQ+e@Fj{;7JZ&%Lv|gyJ9e zoICe@pXc89-uJ%mduR6N@BZ)&02}bF2vlexEHF@qdIhm5>y(wrTkb?=_wgw^=PRgR z@3@Y?L4nqj8Vf;J&@2a)eJ7t8%~`H%7sH4k8iHY<0gX3V89h_-?ScZ;aTT zWG8Lcw~I;7&7Vp7lQscw+AdnY?$($!U-*S@?m{=G>r-4OSte~ap=)Aot2u+Kf z=EX@={FEonb8y^=q12d;Zcg1IcRlVDOMcQV7mm{fVSR~#rNVTbG$IadnSteazk-Ns zpZ2p}`FP%zQOfG*QP3aQDOmnw#c!{e^u1)6yB`=I>L-N-}}M+RS@Q^Aig^G@ry)PR)|mrd@g!Zg z+|rC)q$gPs=%XTs9^zJevZCND1^3*B<pj_QiaR`pvj#pS_=XCYmT zz9341I&a{kVozZP%lC?omDllvg7~nT^NK~@ZneUo>v_+c-s*`c4D)1y9BmrmHg?Gx z+-J%1ijQ~<c>3Y6IhyP*s3nR8*8+ZAjBR zE#Mo1YOIZDzDWZvoM0)j%#daRaH zHK_HyP+%e|uks*^6d1vkSylDml_c^mvbk~@3#BE9(EOJygV`|ZTe*`vt?5eQMMk}H zF=uae#LXX@mr^Um`v*&SL8*Mti}oa*;uGSk;!_244)uIKO)bM-VPBWN2Ibq5euhs$ z6U4{)G%E75_yjct7pjx%n>eBy&|bQZ(4p56zJ{j3`qvSUC+5&0`mQ-7&H6dKZ=29o zRJ7D!olyI#p*SCn)Eh;QUr7&*pc0b4e!~ad& zyVM8FP<-ti?z)V>X#@H!{z`pF>VI4y^xsmyN9w<<6Z+4nZwB@l`=4(M(AD?9}H|7+O+jqFF*j7(3x*1_6%_`X{9W|q*PYT))v?1x`Rl31!Angje zQP7Q&uCLNfW)ta$1sxM~OwjmCm2NhhNtXm27j#_GKdsU&W((=Epj!pqD(S0Ly3K4O zJtOFZphXSL;^`{gZnm#T&EbsTMQxZJlAo&brfCZPF~Khs{6fiZukxK{r{EtK{35|G zl6<<#FE$r*`Hu*?OVBJmE+3^B{}@G4J{nlsii%B?n^@K{epAQ!!O_C6%QhBS0;|x$ zPcai4(W%C;SZzm_x&+Mx)D9QAsy{S`K;zr(%i z@3C3^GqUR6u|<6cTh;$yn^uQmEr#t{2X<(k*r_eUF0CKCwRPB|4PmdA#i+Ii`?Q1D zuRVYR+6f%grg2C+jly#7ue^#Y@B% z(!X|mg;*!OjN+@r7SYE9zD8^@J&j_PSeLk#5nS0zwR3oxcR#-=IQuFk4Xd;wUg5Yp z7(AI*@pWG6-(X&>$CCfz7YK!Tiu`lf9};4}!i15(SmoF7Z|rOdhr?aLue-au>mB}w MQ1DIKQ1ROT0QK;TF8}}l literal 0 HcmV?d00001 diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index cf924736d78f53fe0bcb2a6abf09364c9bca1cba..d70e1c3a68d2c5075d1c70a42ddf347aeb0fbb02 100644 GIT binary patch literal 2215 zcmb7F&sP&y6#ga&nMoJ~f*?q1hoUwCF`@+(5VfWVHvFiuv`BwA3}Z4nnTeAb1<&ce z%P!lEi*7u}o-XPsv8SGPvC(8TLh&@k?op z;HZqeieng+&=uxLraK&HTodlLNTo?MEM!wl!EyvARJ<#MY`Ja+^@@yf31?oTdZp(j zoiTMk@XUG|V~8s_Eup-`+SE;rH8(v?cQkXuu=Q$KW-U9A({7rZn(u1$JC<)$#BALx zvyfVqZKJt#(JFeq;_GECJDA&T>FMhh5rySM8k3lkaYkkTp50x}uxnTXfpdYjVbjhj zIM41F5Pla_6!1Qq&b$@qcKrpVqL!b`T~%!x8BJI zF9dANM7EIQ?g%~-m0ylN@DzT+YF`dDsVlfDq3{2QQLQn2s^T*Nor+`(kz3cTdd=21 z=R=tiky`DdZ@JBkuIM4VOwr}xUDiEIteYPbe#N48Q^nWloEOghBvYyKDv;2VU48kG zr#u4ne_Tg5*N5p2z{$QRbdPPThoMfy9N~g#9wi0~j5O zZ=vfk_N_cb-y^(L93uYP#|(Tfw% zc$FPydmqEe9aKh}d38|43apUIjb~J(@2Em6k)A%r7&AOsY`*8WSuF@Qr^sf6O2Tm$cYi=Oy+@;*Aao(b2<#CWnhDLjSR z!cYA5@eu`^7Qtqt)H9c&pvBWNzYh1x4J%NPrP`(#Y=M={#f{RjW%KT!#Fn#SP&2cx?JR{#J2 delta 477 zcmYk2PfHt76vcnnWb%^9B+gW=)<3P9s!5C;byKS7#^6fZMT^ko&_2Xc6PQFnTy*0X zkogd<6^x)DblY#_MtUa-Ef3Cp_s_ZKop%vD828WP?LDx`>bV={40+*w5;%*aTkY6x z+o*dK+m4GNV<-w6+S>?STrvg93>tiofER-QBRY=4pHXW+{Cv{s+Cw4JKI#f1JIQYu zs;#G_VUH1B3g)17Y~zj z_hV}fGs0T>(DTzE39{GnA@Q9?@c*mV1vyDdPP154@|Sj>nVdS+U(*bzXA}j8oZ_rz zp+?c@)Nhc>e!HTWwxPsZMek{VIp#Ghus~HSDfx`79;n`7zTQySxx>}y?Osu8lzR;I z7=12%{I=9%>Yu>4N}w+D%;4*?30+>%)eEfjMe9$CsZrOtJku=FP+4DpZHag4qM|NB Ny=AnztTO|w`~}~vNyY#G diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class index 42de72eda0500c76c0b1b14286278b55a620aee8..d77558c91affcc7b30cfe35591d2d046e4cc1b87 100644 GIT binary patch delta 1244 zcmaiz%}*0S7{;Gz3)|gpX=8vO+6r7qN`ORSb3S(g0v+h&S|B{mx8S=Ya|&_HO$ZBI zJ14p(3A@8TZ61nxsh6zYRc>bbP_$N&jANGkhY_3b0Dm;3{zA+Q*bw4Otl4-n4` ze?a^MPUbzFw>${k2a?^0qQ{bq8_BqqbOn}lG+&%6*Ba4Wgo}O)?J{VWiDp@o{m}`r zP|rs%jmz5x(GMB>A#K0He-VWGBE0)UO}>r}T0Tb+!!)JeO@Oyc@FsqH&ngexC7ZnhNf7zX+;jGN+e9Q39RaxC$Pp{nDn~V_}Qd!lNz&a zG>T_59&3$7&yM33HRjuBG~$qIGL9!Y3#VRzHFIObSy?lAgEUeop{(vQW9~9zRnJ4X z_ct8z3zw-hrWpZKF_wCz(zpQZ;lfpyEvKY#uOVl+oqA%S*4<-+R_d*`8^;+Io+ErF7 zCk9HPg@$tP1qio5X^UrI7^Y0)WXiOB=(qMmXUc!*=YDOcQ~I3U^+ryt=0iQ&%Q@#g z&w0;tp7(v%fBw(!{|I0|R#NCdOh#NqClV66Pw7i~v8vmZ;*r@?rr}9Q+;7>Iw_idm zm!D2TK~hFa#U`i{_8CsC_?T5UoH_H1RjpZe#dGXp!>~--v*s21MyH)7XKk7E;Vh?k)U|A{?76018&PmG4Gy|)3b)`^8Jddi7?iMi z17ittT}-XoM9T$mK25~pu1E6IVgox=d`)H6KN@vxn?71T`x+5S}42`OI5D(Gix^spG zxe{3y{UsF##grJQBt|>GNWIW|!V;pGQ1P%(gtE4CVLhqhkgz5lC9~q1W}9>3R9R78a^qZKRh0u zcB@H#TEVv^RE}0nyY*RvSE`P0fQkaDyV@`#M z`SmjP)kOrc<^g&@>T~%C1&j!3yO?)M#UiQ6j@H#q{ou(TKMC1M!xY;?=uxb=h-J$xmCB51t3wCvRSQ9(+R5Y<9AtiQLa+H$mjY>lV?T_f|Fy4utYR6cLwTi4PjE1j6fvxT&sV&R;Ka{bIcO@x$)Xk zv0Eet%0^+i0%E*afBbaCtm8kKQuy2qx`G7n&#+bGQ{uC;a0$|H`O<-Bc^AX%#E*Gb z!}oJ|jx7m4K@aa@a)}mVA+?arE?$IO_#Na=*$yy7-2^gV#qx3b{I-e!N8mp1V@r4; zLOe)3f!I~ZUPf0N$X@PoOABOI1lbiqz8FD{g-)gm*mlY~A(M6JWj6iBTS$L~Ej>4_V%rK7pNTa(Vm_sPoCC(Tj9bygbLz(swy_opiUVo} zqcsP^HDBgf93A~}68=iG`gllEw;*ZgGHz?b(=IAtcME=Zgx?+QiB&c{%&SrJZBXwd z>Rs1CWvy<5dV3qxdx(1Pbx>c$Lm}!haw*u%6ta2eGKy_L_aVg(I6<)Ht11%_kikzw zU1#t!zQqXq^LFrewt+uD_);7AUt9zKT08i=+rUo{{^2(8SG*Ss3GZKzDF28Oi*wJT zg$$9i>GSUd(!AG~W{z5Y8-wxv+s zt+YUH-g0Px=u$=w?MW!`i`$+NqnPh z1o@4NI84aHS3@=lxpW=Kch^dg^a0hniHG#%=TK%Y;n-yOJoGuHW(-o!xXD)f&z6HFbV>VRn#xQW*gubl&(J(X2hZ=x@@H?e|lwrhSn z5#O8Gk`OZuUSgj38{j3X-hQ!|!^On&bg*dSKAEkZ{qic#tm3g1aGyh^&xGh8mP^$|<#Ck&X2 zER27^i}({>!e8++{>D@#lG!)|`~nN>1)h$~(G1?>TaqJRh5@JGFQ^lVAIcnmpKl#p y@iKmi59m*xEBp$-ChelW3?cCq<64%Xto^2B%<@MvGV0bH|HKXg{f4F;`0&5e=Gn6V diff --git a/src/out/test/test/com/zipcodewilmington/scientific_calculator/TestMainApplication.class b/src/out/test/test/com/zipcodewilmington/scientific_calculator/TestMainApplication.class index deabc09a7bb2ec24e2595852496d820e0266722f..02d8c0455707c804be2cd2d4893c7437c82186df 100644 GIT binary patch literal 938 zcmbtS+iuf95Iviub#RRv0)-R`4c8_u!XFSQibyLV87k2#5>IGjwqYY@ZPx1`@mIXi z3M4*&k3!5k2@NVzAJ~Uk&F##bnfdwa+YbP{cMjp#3;&GJ6+$1_U{A1h~ z+~ithE*zAtSn=TDGJ_-4MCeQ~R9d}uuZmTwwWqafsvJ{%Wn4-nx+X^AMhe@s@u`liF8}p7A2KdAt0PbRgZrZ*Qn7wL}cSsB9 zXY?;^pMZTS+?yn=8*tGi=}iL&;vQ+hee#xycp#D+Nb-Q$tU#I!!zK ztPQj&8EMIbw0$DA(hl;1ydrN%=ntt_yJ!#XqXX0XTc<;G#53kOw&xz5pzr7h`e~Y0 gr&II`{YGb|J9LgN&?UM?=lX;EA{%6D-CsI;1sugPbpQYW delta 251 zcmW;EF-rn*7=ZEjHt){&5Cji|8*gkX8&Vvs2D8C*=${8!LxqE$L`8!YI6C$pqS48< zZ{}C%;az_`JiBa{{b?8+_`Rk+51k%LMUJE##ZM1`SO|!^p4?RWC&~ww@ zsL(!oA$1u@Q!afFKkE>=LPp3KN&Qb;=r!ul8+2mYs5-qxr#$a?-rMsVeLx@4Cv;|- hsM9&RKudIKx Date: Sun, 26 Jun 2022 15:15:44 -0400 Subject: [PATCH 24/46] Code is almost complete --- .../scientificcalculator/CoreFeatures.java | 100 +++++++++++------- .../scientificcalculator/DisplayWork.java | 40 ++++--- .../scientificcalculator/MainApplication.java | 14 +-- .../ScientificFeatures.java | 6 +- .../scientificcalculator/CoreFeatures.class | Bin 1749 -> 729 bytes .../scientificcalculator/DisplayWork.class | Bin 3686 -> 4644 bytes .../MainApplication.class | Bin 2215 -> 2260 bytes .../CoreFeaturesTest.class | Bin 580 -> 1302 bytes .../CoreFeaturesTest.java | 42 ++++---- 9 files changed, 116 insertions(+), 86 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java index df173e0..cf0226e 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java @@ -24,51 +24,75 @@ public class CoreFeatures { //Each operation should automatically update the display - private static int displayMode; - - public static void setDisplayMode(int givenDisplayMode) { - displayMode = givenDisplayMode; - } + // private int displayMode; +// public void setDisplayMode(int givenDisplayMode) { +// displayMode = givenDisplayMode; +// } - public static void main(String args[]) { + //Subtraction + public double subtract(double number1, double number2) { - double firstNumber; - double secondNumber; - double answer = 0; - String operator; - - Scanner Calculator = new Scanner(System.in); + return number1 - number2; + } - System.out.println("\\\\CALCULATOR\\\\"); + //Addition + public double add(double number1, double number2) { - System.out.println("Enter first number"); - firstNumber = Calculator.nextDouble(); + return number1 + number2; + } - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); + //Multiplication + public double mult(double number1, double number2) { - System.out.println("Enter second number)"); - secondNumber = Calculator.nextDouble(); + return number1 * number2; + } - switch (operator) { - case "+": - answer = firstNumber + secondNumber; - break; - case "-": - answer = firstNumber - secondNumber; - break; - case "/": - answer = firstNumber / secondNumber; - break; - case "*": - answer = firstNumber * secondNumber; - break; - default: - System.out.println("Incorrect operator"); - break; - } + //Division + public double div(double number1, double number2) { - System.out.println(answer); + return number1 / number2; } -} + +// public static void main(String args[]) { +// +// double firstNumber; +// double secondNumber; +// double answer = 0; +// String operator; +// +// Scanner Calculator = new Scanner(System.in); +// +// System.out.println("\\\\CALCULATOR\\\\"); +// +// System.out.println("Enter first number"); +// firstNumber = Calculator.nextDouble(); +// +// System.out.println("Enter math operator to use for this calculation"); +// operator = Calculator.next(); +// +// System.out.println("Enter second number)"); +// secondNumber = Calculator.nextDouble(); +// +// switch (operator) { +// case "+": +// answer = firstNumber + secondNumber; +// break; +// case "-": +// answer = firstNumber - secondNumber; +// break; +// case "/": +// answer = firstNumber / secondNumber; +// break; +// case "*": +// answer = firstNumber * secondNumber; +// break; +// default: +// System.out.println("Incorrect operator"); +// break; +// } +// +// System.out.println(answer); +// } +//} +} \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java index 04f409c..895b39a 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java @@ -3,8 +3,9 @@ import java.util.Scanner; public class DisplayWork { - int loopFor; - double answer; + private int loopFor; + private double answer; + private boolean onButton; public void store() { @@ -26,22 +27,27 @@ public void store() { switch (operator) { case "+": - answer = firstNumber + secondNumber; - System.out.println(answer); + CoreFeatures additionFormula = new CoreFeatures(); + String additionFormulaRead = String.valueOf((int)additionFormula.add(firstNumber, secondNumber)); + System.out.println(additionFormulaRead); break; case "-": - answer = firstNumber - secondNumber; - break; + CoreFeatures subtractionFormula = new CoreFeatures(); + String subtractionFormulaRead = String.valueOf((int)subtractionFormula.subtract(firstNumber, secondNumber)); + System.out.println(subtractionFormulaRead); case "/": - answer = firstNumber / secondNumber; - break; + CoreFeatures divisionFormula = new CoreFeatures(); + String divisionFormulaRead = String.valueOf((int)divisionFormula.div(firstNumber, secondNumber)); + System.out.println(divisionFormulaRead); case "*": - answer = firstNumber * secondNumber; - break; + CoreFeatures multiplyFormula = new CoreFeatures(); + String multiplyFormulaRead = String.valueOf((int)multiplyFormula.mult(firstNumber,secondNumber)); + System.out.println(multiplyFormulaRead); case "**": ScientificFeatures squareFormula = new ScientificFeatures(); - String squareFormulaPrint = String.valueOf(squareFormula.square(firstNumber)); + String squareFormulaPrint = String.valueOf((int)squareFormula.square(firstNumber)); System.out.println(squareFormulaPrint); + break; case "*/": ScientificFeatures squareRootFormula = new ScientificFeatures(); @@ -97,13 +103,21 @@ public void store() { System.out.println("Incorrect operator"); break; } - if() { + Scanner inputEsc = new Scanner(System.in); + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if(inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { System.out.println("\033[H\033[2J"); System.out.flush(); + }else { + System.out.println("Please enter the correct letter"); } + } + } -} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 6bb5b7d..774b328 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -34,8 +34,9 @@ public static void main(String[] args) { // DisplayWork g = new DisplayWork(); // g.store(); - MainApplication z = new MainApplication(); - z.clearScreen(); + CoreFeatures x = new CoreFeatures(); + String xPrint = String.valueOf((int)x.mult(5,6)); + System.out.println(xPrint); } @@ -44,14 +45,7 @@ public static void main(String[] args) { //clear display String xinput = " "; int z; - public void clearScreen() { - z = 0; - Scanner x = new Scanner(System.in); - xinput = x.nextLine(); - System.out.println("\033[H\033[2J"); - System.out.flush(); - z++; - } + public void radianOrDegree() { diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 6ee8d26..f472a06 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -3,10 +3,10 @@ import java.util.Scanner; public class ScientificFeatures { - double result; + private double result; - double toRadian; - double toDegree; + private double toRadian; + private double toDegree; diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class index ecf54e75ba199fec4604f0926eb61e3f5f2d3f9e..54f685ae2ea990e557549c79cd4b1e8f5a2c6805 100644 GIT binary patch literal 729 zcmbV|%TB^T6o&t?g(9L{ye>5{5m;Dtp)nd3LRb-9XxLAuBM!D5Q(8=XDdWn-g%99E z8P8M_31LB;#ktM=-KX6CJy49m}rdNgB%$gWVBoX?@YJfc1Wy)Og%v782 zU~d#Gp-9$TgQ69(rQZkSS1DsyLz%1*U%@66U>`IFujHq-`jmUp@^Z!6o>_7AF1aNz&| literal 1749 zcmbVNTW=Fb6#mAS?AqDjTu4Zu1XG&Cn>1`_z>qkE2AdR9hfo~c0_kP5*(3}0uDf1C z=|AZ&K`gTL0d(&yutLB3h zY6^&=f&&75q4#FsRE@G_x~}af(2G6={Tc>va9?=k2aUk42}B%MV6YTwI-XH<>&>7X z__kTgCDDT+nb;wL;mj+K$c%b1qTw)(Fhj4&gkKoD<~wfNn2MtU2iDi~OQrmc($d=M z_4V~6jv=k!xQ5qpLSUdBM2DV$QkPb$GRnOeLUOe#)sr)9ihTb{eQ7m}XDEKVypqalm4`^yogBcSe> zjh%d0RK{6UF~{moNxhtg1)OI;*`GGeDqCP59IbB4>9EMW2EWdfmdwv#)Qq$N{N^h1hiIh z+Dl!g+qiH0tU%7e;W#8jCpN0q@6`quj17}gr`KoX%QZmQ|d3^E-#8;d|aD}7X236kWsI?BDgcV8& zT*WF^r1C6zsC@V_lo!hK^#Vo_V;^)HxEA_P;5}S#84yo-rklZu19S0j&~x(|92T%No0{)h_kkyif zSY%xZHp*C|G=`sXgU|?`{0{GP7UlmLKHw})4?o~0Zb4xbf8jRP*+?ITTHXI5fU4l5 eXq4ZmSp_{D=_8d&X`>2%|4>QbV;+v+lm7tL(}k`8 diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayWork.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayWork.class index 8ab1afe96f5a57e0d8a9b4e10de02bdfd7ec1dc3..7cd47359332c50c76a55b0966babcc076ab90ce8 100644 GIT binary patch delta 2477 zcmZXVYj7J^8HV58BTKThwiDTwyuNAUyOUBop)}NCl7f{q4k76{WfCX7pvY@`V_9;f zmD7ZaAZ@uc5C|%lhD+PDB`u|;Ns67ukkUeF2~aMjK>l>-4ATxX{9^b)f3)y^D=TAy zX3p7j-sd~#e0tBP)tjx4bcHUxd*LF0jktUw^qTg-iNCHX)oAazX(E}j`q;VIoRduV zTOrHI%-OlTZRMSeZKbl_!%b$&#G5&pC7GcllXk{EH>&+h^9Qg;!}`+GYE5xCo3ppr zNw<)*^C9epl5U@YTXCBPl^h?}P}P@6^d~|X#2p4chNOnTTryp-cTQ+%>>KIdejquQ z97ywkfn9FS$xLpLJyHh7WshLKu;0xwaSI@tZ!8cP#y8)z2PpS`X zoR%!6ku@-jgBtw#gN0BA($29T=Tp^({8O>(7`yl2dy+b9-*Ib;&VFO3XF^3#C zHMPr`%*dvnFt8N|W%MZn+sdO)8`xeR9W}6{Ji6P!J(5^>$>v>jSyp|{z~@D;S<;6+ zTQ4UrMvP%dYuTq`?k=aRhKAik<$b0TXU z&K9gg$&72cSEO*Mb#-0BBY&v;3 zi2F2XV`9zM4SWON)Ud*)m+Ab-WQO-X%*{$gEjGG0h?9)m5yZE7xh?y)w(MKCEd&$a zHShrZEP;u1AwLzwLmJ}$lY|^s`3h;D zc&Eus{*Wz`L@8c%q@j+L=D1Ea!w8lFYwU*YvPb9g`rM$Q{;If9J2_r@w<=bQRLX4m z9?}07Wr2n|)}NDK9$J5uvJ@v}>CC1NUrDR}Dy1A(Q#x5Sajwz-u+|iGGP4DDb3UcP zs0_U<=L7F8o`TNbwzNm^D0|?0IL%%MJ%*qCW1J1}sqtC0dI8!Q4?oUcFhzWyy|FZY z0zcqP!;_W8fni4U0>1YzA~1Fq)eEQ_@}ET{5}n7nso;WE)GaQNPc7Sawi&i#Y;wp; zY;SQ#KU+6jf-S{%l2Vap?Nf&)-F~8 z!e&?k_Im-wSrj9t!H5d3F>3_d9tq}X2H!Kez}5M%ogIJ;8ww{9)5hWxRhL**+%{u;qAiPJ$`RxdEAW4H@{1`CEW7( zfeK$`t`h!P;T^&|Jie{MJIzkvUl86UyvyUOubkg)cJur%3hxo#>NfiH8LZalutvWN*XYM^t$rT{^anAhKZbSs z6Sz))2Jh3K!}a=0Sg&8g4f?AX(qG30{Y`v8|2sD7|HLN!9o(p@@Ie*Cuv&?PYQ<*N zg)K$Zi>+!9BWeS-sbPFrZNW#>PV7*7u~Y5G&C158%3zl|f?L#4d{o_o-Rd~@sFN5| zr?6K&id)rFxJ_Na?dk>Gpp?N=8^A%|dKBc>thwmcO*G*t{1DajC5)$W1|hoAh_lqf^d^XN)C{`Qh-awP(4!!J zM6H%CHDaDx9lZ)-f!YeX6~lQvixenPR4=7n*Q zT9npB@f@`n4GiO_)S75t6wgyLX<`^JP-~`xQT&Wr3w;dZ=hRy1ViYe@YonK8{DN9L zos99#@+{)?GmMu}JOhh%#_&sut7vK%ml)VVOJn#IwN4rv#;>V$(bgz_L#(Kx{_PAu%+3oHxla(P)^28Xv2XwnE&OgBf7)DaW#1=(=HMcl<@0n>CP zEz@3%)}qX^d05w>stU;;nQi?k0LhxTZ3>VU1DibI5H86jfE=4!jVwLK-9j)gOQ54g!ogq zo#;VtCU%(EiCqHAlTBF-$y1K(Dn~FfHW`Wuh=2B@u) z{ZP8uYa)a}0ms@yL@ut4TSaAZ8RnKgwRq;ohp5o{a@Mur-@;<0dK zs7;SDV&Z@v#g!UmYcv|ya@53VN}deI2ljP^hay^znF*}Npibi^I#St$iOy7Z$i${p zcG$!bJS|`>E=CvELLj3y5UAr6`*F-fLi6lJzSdqQO{Ppdqe;#p*~STnBKD+Cns_!( z&&oL%9Ee9_;owLXP9>umg*h}k5{-_oi|X~;ki6kIob+c6<$L~bdhSHlRgqldY98r< zRYD~Hj^=w}Qw;*4XAw;A6seqsE@p)5uVqnk0wm|-l`*VGMsiSEzg zss94q^VmHrrl<{3n-!DHqIPzG*?v14xQYJW1w5H(bz07vc?^7op;j0BTdsK&&5FPx zZ#67~c)!M`#-@#zq;a;DO&rlUN8=nDJJLAU$|XLiv0G!e#`ryr^Q=T3`IzP&%{?~% zF3t0;eByD93p6gU@%1z=v{4sG%#R>)geCBH?x`~j=w&v;bc z!CHA20r>|WllQPLA^*mDm4OY)jSf|Wjj9BXt7>dgP1vkjutl|Ds|uh?ZNWCxgD2EZ zbgRASQKRTphplCx;#lQ@;96Ish4QjdcW8h6{Zo2W}JheP}GVm5P4;^`Nfm%L& z89X*g6ws6x?@%kGH3Ju^d1=gtcd7Yk&%k>~CQw9oK3t+`(W8OOEG(u&AFfa zsg=^D7w=OmqgMm7)cpD^BX!QJ)D*7qhau3;-q)EaG^-dsU|j}GuFZ$|h<}0`+zl&G j`7gdlW+p^W@=jhwX};6x^rx=!@^b$@klFgyI293s^+w5)EiZ^79@n*HyIP6Jif_z3)sh3A7d#FMSEij~Z4d9zWM(oJI{n_99K zTor$Ytj_Bae?^^4+x<@HOmbP_Uo&cJQzG)PSM!Dwaee0RK=WLn}bw08q1geh33D8z3);3GVPTr|n*~Q(n zLY{p!YK6V&ju$5(D-~}q$Q{?%jgeg1F>+1P|vi1?ggiHtw=2Yk)P1HeYa2eBHA49uQjICo(q}BN`*tq~r6) z9M3l{FUArZlBH8{St@o3uC(d| z^^JsS6W;F!q$Th9xx+PoKxX+7uk3SiUUElAB>A}}V`H8!&zRRWV_xnzxKJ+UiI za$nQo9`fxG?(#-wWN)o&iQT^F8{%bq&$YbgM>W|E#`gx z4>b9}A-V0Q-A>cfL)ca)kz6Jm%>J`wa(P*qUC7US@O{QSaoY9d%z>~%pdN%@!tTT)PphkPo6 ode|191it4o+?qyEBW=IkWHe65D|a5!kDvNW{&vNVa9!N{2M|!=sQ>@~ delta 1240 zcmY*ZO>Yxd6g|%~_KYXf#2@)~NJ$K7;*dHCb%25ZY#lhs3EfrvB)c zR9P%4v80+s+f5eTM55}VsBusu*syCCNYHJ6NUN&tnXwU6n)lv)@7;Uux#vF3@4=m* z_Uk{tJOXeEwXe19x&{rBGX-^o;1g(DE1E_*w^lYy%g^&p9bM=a5MOX)6!Z!NH;qq> zc&%C}#&c_iWtn9^`VmnupyL1r1p=-^(XiIzxz8(Ab4$QeumrlY?nR*#&seu=)m*jQ zZW>!j4Lvxh!;2w%(-YC0ZB)l09Jc@V3~LVdYdS_TW`8OM52zRyP$Dbyk(KEM4HI}> zL0rcqrUb(FZ4tH~h~X~h;;4={oQk|Ri?zyzf*Jb{aaKw|vcK|_Qc0Xt@TN{3PXC{9 zwOp{)1=J0rvT?4IHwC28v5bl{tba&D66bWJ@s_hBxzsw-m(AkUZ{V7ZZ;fv1?}$2 zesYyTY2f4hA$KR>p#`+X_8?**Wf%URxbY6@x?AWsvCcb{q`HVpWt|7v!u^tQ4(?P;+C_LD zJv#cCde)|EBDE> zUeAoL&)dN44-5s4b2tSJaYQ(x9OHf7P^y8m-=SNY@$DeM{T%o9H%hcV5}I$87g}iI zW=|;0GTy5+aH)YSI~aA6zT0wIe(vNbbEMbbz>4c6IlYivJ?0RkouuL?smCeONRh@F zb|sBFn8RJ1$G4crHZr(Z#{zyt7Q0x)L%!_CxQHjXgr~UT3O7%2x6y%*P^9&k))p;4 z6Fh5)sp2;RSrjwC`w}e=Q$D~g3M?_{J$%gfDWlAoD184CTv4DYNI2gBdK4u237|vo PKlCU64+0hXdQkljA&S<4 diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.class index fa92b542a3ee382f92330aedb116b6a9d10ac30c..953e4a8b61e1adb6958318dcd198856a7b71fd36 100644 GIT binary patch literal 1302 zcmbW0YflqF6o%jFWf$t&R?-%gq6Ji-D(fAwP)aC7lSUIHP5e0BjyPnyi+jPue`TU# zG%Htg-^9jaNAaq&#=}xqf$d_mBQJ1`GJ@`}bI83@nhN7CH# zec=Vtb*M&zN0XhmA-8E7>2(!s&cM8arFp-vwN^$|+%T}HHZp_I4z$*@(auc+x1zuF z<*~N;Yq&v)+jJ=mg^qN@^Kj4;-ahZyv@+Fk=~}wnlWHC>W`Z}83fVZTcgp()o$Ieh z!&}MFbf1B>87}RG)Di>HmA)kGmgBeqkKL$tk{ydhb@C$CQxV;S@?f}J zh#~jV4LwWjN_FJ&zs;x8R#bPRMjeDh_#T!Dif^ v>8$I-T1sNg5UWb8*)gp31lGpstU9r7C$Z*;HBYRCF|6i)EQU?;F@@G2`2742 delta 278 zcmbQnb%cfM)W2Q(7#JAr7(^y=nJ`*U7G$!Xe1ox^pRYKz#3i%1ASbcXH$NqHaypYO zD@$@>PV(gIOd9p<3`{^x3=GUb%*w#Vz{tP}Wa$HGMv#csb_T|cKn4>77mx%=Gcd3- za05vmhyozZ3*<2{@Bw9+z?!vzJdipJjoe5Y86g^@8Tf%JLFNhoX$A&C!lnpdnu1~o MBZCmoASMQ30IEJ2D*ylh diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java index 87a5e7e..957c963 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java @@ -1,38 +1,36 @@ package com.zipcodewilmington.scientificcalculator; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; class CoreFeaturesTest { + CoreFeatures allTests = new CoreFeatures(); + + @Test - void setDisplayMode() { + void subtractTest() { + double subT = allTests.subtract(5, 10); + Assertions.assertEquals(-5.0, subT); } @Test - void calc() { - + void addTest() { + double addT = allTests.add(5, 10); + Assertions.assertEquals(15.0, addT); } - //Addition - - - - // Subtraction - - - - // Multiplication - - - - // Division - - - // Divide by zero - - - + @Test + void multTest() { + double multT = allTests.mult(5, 10); + Assertions.assertEquals(50.0, multT); + } + @Test + void divTest() { + double divT = allTests.div(5, 10); + Assertions.assertEquals(0.5, divT); + } } \ No newline at end of file From a3bcff80b24ffddd8240ef63d13ef60ca78c07cf Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 16:46:14 -0400 Subject: [PATCH 25/46] Program works, cleaning up exit conditions --- .../scientificcalculator/DisplayWork.java | 258 ++++++++++++------ .../scientificcalculator/MainApplication.java | 6 +- .../scientificcalculator/DisplayWork.class | Bin 4644 -> 6126 bytes .../MainApplication.class | Bin 2260 -> 2154 bytes .../ScientificFeatures.class | Bin 2763 -> 2763 bytes 5 files changed, 172 insertions(+), 92 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java index 895b39a..debc890 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java @@ -3,121 +3,201 @@ import java.util.Scanner; public class DisplayWork { - private int loopFor; + private double answer; private boolean onButton; + private double firstNumber; + private double secondNumber; + private String switchSignFormulaHolder = ""; + private String switchSignFormulaHolderNegSecond = ""; - public void store() { - double firstNumber; - double secondNumber; + public void calcRun() { + onButton = true; String operator; Scanner Calculator = new Scanner(System.in); - System.out.println("Please enter only these operations + - / * (square) ** */ (squareRoot) +/-(switch sign) fac (factorial) \n inverse sine cosine tan \n invsine incosine invtangent"); - - System.out.print("Enter first number "); - firstNumber = Calculator.nextDouble(); - - System.out.print("Enter math operator to use for this calculation "); - operator = Calculator.next(); - - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - - switch (operator) { - case "+": - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int)additionFormula.add(firstNumber, secondNumber)); - System.out.println(additionFormulaRead); - break; - case "-": - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int)subtractionFormula.subtract(firstNumber, secondNumber)); - System.out.println(subtractionFormulaRead); - case "/": - CoreFeatures divisionFormula = new CoreFeatures(); - String divisionFormulaRead = String.valueOf((int)divisionFormula.div(firstNumber, secondNumber)); - System.out.println(divisionFormulaRead); - case "*": - CoreFeatures multiplyFormula = new CoreFeatures(); - String multiplyFormulaRead = String.valueOf((int)multiplyFormula.mult(firstNumber,secondNumber)); - System.out.println(multiplyFormulaRead); - case "**": + ScientificFeatures switchSignFormula = new ScientificFeatures(); + Scanner inputEsc = new Scanner(System.in); + + + + while (onButton != false) { + System.out.println("For addition, subtraction, division or multiplication please enter one of these as operator: + - / * "); + System.out.println("For the square, square-root, switch sign, fac, please enter one of these as the operator (square) ** */ (squareRoot) +/-(switch sign) fac (factorial)"); + System.out.println("For the inverse sine cosine tan invsine incosine invtangent, please type one of the respective operators."); + + System.out.println(); + System.out.print("Enter first number "); + firstNumber = Calculator.nextDouble(); + + System.out.print("Enter math operator to use for this calculation "); + operator = Calculator.next(); + + if(operator.equalsIgnoreCase("+/-")) { + String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); + switchSignFormulaHolder = switchSignFomrulaRead; + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + System.out.println("Enter math operator to use for this calculation (if another negative number, please enter +/- again)"); + operator = Calculator.next(); + if(operator.equalsIgnoreCase("+/-")) { + String switchSignFormulaReadSecond = String.valueOf((int) switchSignFormula.switchSign((secondNumber))); + switchSignFormulaHolderNegSecond = switchSignFormulaReadSecond; + System.out.println("Enter math operator to use for this calculation"); + operator = Calculator.next(); + if(operator.equalsIgnoreCase("+")) { + CoreFeatures additionFormula = new CoreFeatures(); + String additionFormulaRead = String.valueOf((int) additionFormula.add(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); + System.out.println(additionFormulaRead); + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } else { + System.out.println("Please enter the correct letter"); + } + + }else if(operator.equalsIgnoreCase("-")) { + CoreFeatures subtractionFormula = new CoreFeatures(); + String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); + System.out.println(subtractionFormulaRead); + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } else { + System.out.println("Please enter the correct letter"); + } + } + } + } else { + System.out.println("Enter math operator to use for this calculation"); + operator = Calculator.next(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + } + + + + + +// String switchSignFormulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); +// System.out.println(switchSignFormulaRead); + + + switch (operator) { + case "+": + CoreFeatures additionFormula = new CoreFeatures(); + String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); + System.out.println(additionFormulaRead); + break; + case "-": + CoreFeatures subtractionFormula = new CoreFeatures(); + String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); + System.out.println(subtractionFormulaRead); + break; + case "/": + CoreFeatures divisionFormula = new CoreFeatures(); + String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); + System.out.println(divisionFormulaRead); + break; + case "*": + CoreFeatures multiplyFormula = new CoreFeatures(); + String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); + System.out.println(multiplyFormulaRead); + break; + case "**": ScientificFeatures squareFormula = new ScientificFeatures(); - String squareFormulaPrint = String.valueOf((int)squareFormula.square(firstNumber)); + String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); System.out.println(squareFormulaPrint); - - break; - case "*/": - ScientificFeatures squareRootFormula = new ScientificFeatures(); - String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); - System.out.println(squareRootFormulaPrint); - break; - case "+/-": - ScientificFeatures switchSignFormula = new ScientificFeatures(); - String switchSignFormulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); - System.out.println(switchSignFormulaRead); - break; - case "inverse": - ScientificFeatures inverseFormula = new ScientificFeatures(); - String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); - System.out.println(inverseFormulaRead); - break; - case "sine": - ScientificFeatures sineFormula = new ScientificFeatures(); - String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); - System.out.println(sineFormulaRead); - break; - case "cos": + break; + case "+/-": + String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); + System.out.println(switchSignFomrulaRead); + break; + case "*/": + ScientificFeatures squareRootFormula = new ScientificFeatures(); + String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); + System.out.println(squareRootFormulaPrint); + break; + case "inverse": + ScientificFeatures inverseFormula = new ScientificFeatures(); + String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); + System.out.println(inverseFormulaRead); + break; + case "sine": + ScientificFeatures sineFormula = new ScientificFeatures(); + String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); + System.out.println(sineFormulaRead); + break; + case "cos": ScientificFeatures cosineFormula = new ScientificFeatures(); String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); System.out.println(cosineFormulaRead); - break; - case "tan": - ScientificFeatures tanFormula = new ScientificFeatures(); - String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); - System.out.println(tanFormulaRead); break; - case "invsine": - ScientificFeatures arcSine = new ScientificFeatures(); - String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); - System.out.println(arcSineRead); + case "tan": + ScientificFeatures tanFormula = new ScientificFeatures(); + String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); + System.out.println(tanFormulaRead); break; - case "invcosine": - ScientificFeatures arcCosine = new ScientificFeatures(); - String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); - System.out.println(arcCosineRead); + case "invsine": + ScientificFeatures arcSine = new ScientificFeatures(); + String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); + System.out.println(arcSineRead); break; - case "invtangent": + case "invcosine": + ScientificFeatures arcCosine = new ScientificFeatures(); + String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); + System.out.println(arcCosineRead); + break; + case "invtangent": ScientificFeatures arcTan = new ScientificFeatures(); String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); System.out.println(arcTanFormula); break; - case "fac": + case "fac": ScientificFeatures factorialFormula = new ScientificFeatures(); String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); System.out.println(factorialFormulaRead); break; - default: - System.out.println("Incorrect operator"); - break; - } - Scanner inputEsc = new Scanner(System.in); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if(inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - }else { - System.out.println("Please enter the correct letter"); - } + default: + System.out.println("Incorrect operator"); + do { + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } else { + System.out.println("Please enter the correct letter"); + } + break; + } while(!wrongOperator); + } + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } else { + System.out.println("Please enter the correct letter"); + } + } } - } +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 774b328..519cbe6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -34,9 +34,9 @@ public static void main(String[] args) { // DisplayWork g = new DisplayWork(); // g.store(); - CoreFeatures x = new CoreFeatures(); - String xPrint = String.valueOf((int)x.mult(5,6)); - System.out.println(xPrint); + DisplayWork start = new DisplayWork(); + start.calcRun(); + } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayWork.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayWork.class index 7cd47359332c50c76a55b0966babcc076ab90ce8..63a927413c660088ce5fe0e01e9d3fe36fd0c5b1 100644 GIT binary patch literal 6126 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 Md?b`6D$RK94-34p_y7O^ delta 986 zcmYjQOHUI~6#ni^J2M>yfm)#jf{rLOsI{-a+w5Gmd zr`E<=y8BaU^PFi|*|eEaQ36p4dx%1x6!sQ?yAy$rvG1~f91E*MLOo-mSg`uIx5G8g#=R#U8^837qV z4TsRer-XJeWeG(`mxj~m=IcVkp(^xh2;&TcGH+z&`%^KKK@0>3 z74$Q(Iu%totKl5Zb4m1j25HZ)V2DAAm~&~aI1Sz9PwkJ1CjhMp?AQ1GfjB9Lk@(LFMokYC}0RZ4yO* z9okJnfkr53LIn-BhPt&=)E2@Zwt%~&Dr8Jxk+M_}PEy4J;Z&hcfUQ%QBI14CL5T7m zj_%3f9q1EVIJ%9KBb3|SPRUzy=a>*X79oLd*c)WAM3I7cjR$lR4lI+8 jAJQMXQ?d+IMkv2@8CA4sRwY_x!w-5>3@b#XqkH%l05P|e diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class index d77558c91affcc7b30cfe35591d2d046e4cc1b87..6978487a917ebf54b89caa0df99dc0573d5a2de9 100644 GIT binary patch delta 30 hcmX>tdRlaYDvKZ!12+Q?0|NsSgBOI}Y{oK`4FFZ61f~E0 delta 30 ecmX>tdRlaYDvKZk12+Q?0| Date: Sun, 26 Jun 2022 17:22:40 -0400 Subject: [PATCH 26/46] Finished the program, trying to handle problems --- .../scientificcalculator/CoreFeatures.java | 4 + .../scientificcalculator/DisplayWork.java | 367 +++++++++++------- .../scientificcalculator/CoreFeatures.class | Bin 729 -> 1057 bytes .../scientificcalculator/DisplayWork.class | Bin 6126 -> 7538 bytes 4 files changed, 221 insertions(+), 150 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java index cf0226e..9114e17 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java @@ -54,6 +54,10 @@ public double div(double number1, double number2) { return number1 / number2; } + public void clear() { + System.out.println(System.lineSeparator().repeat(100)); + } + // public static void main(String args[]) { // // double firstNumber; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java index debc890..4e5341f 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java @@ -10,6 +10,7 @@ public class DisplayWork { private double secondNumber; private String switchSignFormulaHolder = ""; private String switchSignFormulaHolderNegSecond = ""; + private boolean wrongOperator; public void calcRun() { @@ -19,185 +20,251 @@ public void calcRun() { Scanner Calculator = new Scanner(System.in); ScientificFeatures switchSignFormula = new ScientificFeatures(); Scanner inputEsc = new Scanner(System.in); - + CoreFeatures clear = new CoreFeatures(); while (onButton != false) { - System.out.println("For addition, subtraction, division or multiplication please enter one of these as operator: + - / * "); - System.out.println("For the square, square-root, switch sign, fac, please enter one of these as the operator (square) ** */ (squareRoot) +/-(switch sign) fac (factorial)"); - System.out.println("For the inverse sine cosine tan invsine incosine invtangent, please type one of the respective operators."); + wrongOperator = true; + System.out.println("For addition, subtraction, division, or multiplication please enter one of these as operator: + - / * "); + System.out.println("For the square, square-root, switch sign or fac, please enter one of these as the operator **(square) */ (squareRoot) +/-(switch sign) fac (factorial)"); + System.out.println("For the inverse, sine, cosine, tan, invsine, incosine or invtangent, please type one of the respective operators."); System.out.println(); System.out.print("Enter first number "); firstNumber = Calculator.nextDouble(); - - System.out.print("Enter math operator to use for this calculation "); - operator = Calculator.next(); - - if(operator.equalsIgnoreCase("+/-")) { - String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); - switchSignFormulaHolder = switchSignFomrulaRead; - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - System.out.println("Enter math operator to use for this calculation (if another negative number, please enter +/- again)"); - operator = Calculator.next(); - if(operator.equalsIgnoreCase("+/-")) { - String switchSignFormulaReadSecond = String.valueOf((int) switchSignFormula.switchSign((secondNumber))); - switchSignFormulaHolderNegSecond = switchSignFormulaReadSecond; - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - if(operator.equalsIgnoreCase("+")) { - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(additionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + if(!Calculator.hasNextDouble()) { + System.out.println("Incorrect operator"); + do { + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); String inputEscRead = inputEsc.next(); if (inputEscRead.equalsIgnoreCase("Y")) { onButton = false; } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); + DisplayWork reRun = new DisplayWork(); + clear.clear(); + reRun.calcRun(); } else { System.out.println("Please enter the correct letter"); } + break; + } while (!wrongOperator); + } - }else if(operator.equalsIgnoreCase("-")) { - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(subtractionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); - } + System.out.print("Enter math operator to use for this calculation "); + operator = Calculator.next(); + if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || + !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || + !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { + System.out.println("Incorrect operator"); + do { + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + DisplayWork reRun = new DisplayWork(); + clear.clear(); + reRun.calcRun(); + } else { + System.out.println("Please enter the correct letter"); } - } - } else { - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - } + break; + } while (!wrongOperator); + if (operator.equalsIgnoreCase("+/-")) { + String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); + switchSignFormulaHolder = switchSignFomrulaRead; + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + if(secondNumber!= answer) { + System.out.println("Incorrect operator"); + do { + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + DisplayWork reRun = new DisplayWork(); + clear.clear(); + reRun.calcRun(); + } else { + System.out.println("Please enter the correct letter"); + } + break; + } while (!wrongOperator); + } + System.out.println("Enter math operator to use for this calculation (if another negative number, please enter +/- again)"); + operator = Calculator.next(); + if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || + !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || + !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { + System.out.println("Incorrect operator"); + do { + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + clear.clear(); + } else { + System.out.println("Please enter the correct letter"); + } + break; + } while (!wrongOperator); + } + if (operator.equalsIgnoreCase("+/-")) { + String switchSignFormulaReadSecond = String.valueOf((int) switchSignFormula.switchSign((secondNumber))); + switchSignFormulaHolderNegSecond = switchSignFormulaReadSecond; + System.out.println("Enter math operator to use for this calculation"); + operator = Calculator.next(); + if (operator.equalsIgnoreCase("+")) { + CoreFeatures additionFormula = new CoreFeatures(); + String additionFormulaRead = String.valueOf((int) additionFormula.add(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); + System.out.println(additionFormulaRead); + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } else { + System.out.println("Please enter the correct letter"); + } + } else if (operator.equalsIgnoreCase("-")) { + CoreFeatures subtractionFormula = new CoreFeatures(); + String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); + System.out.println(subtractionFormulaRead); + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + clear.clear(); + } else { + System.out.println("Please enter the correct letter"); + } + } + } + } else { + System.out.println("Enter math operator to use for this calculation"); + operator = Calculator.next(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + } // String switchSignFormulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); // System.out.println(switchSignFormulaRead); - switch (operator) { - case "+": - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); - System.out.println(additionFormulaRead); - break; - case "-": - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); - System.out.println(subtractionFormulaRead); - break; - case "/": - CoreFeatures divisionFormula = new CoreFeatures(); - String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); - System.out.println(divisionFormulaRead); - break; - case "*": - CoreFeatures multiplyFormula = new CoreFeatures(); - String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); - System.out.println(multiplyFormulaRead); - break; - case "**": - ScientificFeatures squareFormula = new ScientificFeatures(); - String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); - System.out.println(squareFormulaPrint); - break; - case "+/-": - String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); - System.out.println(switchSignFomrulaRead); - break; - case "*/": - ScientificFeatures squareRootFormula = new ScientificFeatures(); - String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); - System.out.println(squareRootFormulaPrint); - break; - case "inverse": - ScientificFeatures inverseFormula = new ScientificFeatures(); - String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); - System.out.println(inverseFormulaRead); - break; - case "sine": - ScientificFeatures sineFormula = new ScientificFeatures(); - String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); - System.out.println(sineFormulaRead); - break; - case "cos": - ScientificFeatures cosineFormula = new ScientificFeatures(); - String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); - System.out.println(cosineFormulaRead); - break; - case "tan": - ScientificFeatures tanFormula = new ScientificFeatures(); - String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); - System.out.println(tanFormulaRead); - break; - case "invsine": - ScientificFeatures arcSine = new ScientificFeatures(); - String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); - System.out.println(arcSineRead); - break; - case "invcosine": - ScientificFeatures arcCosine = new ScientificFeatures(); - String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); - System.out.println(arcCosineRead); - break; - case "invtangent": - ScientificFeatures arcTan = new ScientificFeatures(); - String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); - System.out.println(arcTanFormula); - break; - case "fac": - ScientificFeatures factorialFormula = new ScientificFeatures(); - String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); - System.out.println(factorialFormulaRead); - break; - default: - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - - } else { - System.out.println("Please enter the correct letter"); - } + switch (operator) { + case "+": + CoreFeatures additionFormula = new CoreFeatures(); + String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); + System.out.println(additionFormulaRead); break; - } while(!wrongOperator); - } - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); + case "-": + CoreFeatures subtractionFormula = new CoreFeatures(); + String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); + System.out.println(subtractionFormulaRead); + break; + case "/": + CoreFeatures divisionFormula = new CoreFeatures(); + String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); + System.out.println(divisionFormulaRead); + break; + case "*": + CoreFeatures multiplyFormula = new CoreFeatures(); + String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); + System.out.println(multiplyFormulaRead); + break; + case "**": + ScientificFeatures squareFormula = new ScientificFeatures(); + String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); + System.out.println(squareFormulaPrint); + break; + case "+/-": + String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); + System.out.println(switchSignFomrulaRead); + break; + case "*/": + ScientificFeatures squareRootFormula = new ScientificFeatures(); + String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); + System.out.println(squareRootFormulaPrint); + break; + case "inverse": + ScientificFeatures inverseFormula = new ScientificFeatures(); + String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); + System.out.println(inverseFormulaRead); + break; + case "sine": + ScientificFeatures sineFormula = new ScientificFeatures(); + String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); + System.out.println(sineFormulaRead); + break; + case "cos": + ScientificFeatures cosineFormula = new ScientificFeatures(); + String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); + System.out.println(cosineFormulaRead); + break; + case "tan": + ScientificFeatures tanFormula = new ScientificFeatures(); + String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); + System.out.println(tanFormulaRead); + break; + case "invsine": + ScientificFeatures arcSine = new ScientificFeatures(); + String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); + System.out.println(arcSineRead); + break; + case "invcosine": + ScientificFeatures arcCosine = new ScientificFeatures(); + String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); + System.out.println(arcCosineRead); + break; + case "invtangent": + ScientificFeatures arcTan = new ScientificFeatures(); + String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); + System.out.println(arcTanFormula); + break; + case "fac": + ScientificFeatures factorialFormula = new ScientificFeatures(); + String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); + System.out.println(factorialFormulaRead); + break; + default: + System.out.println("Incorrect operator"); + do { + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + clear.clear(); + wrongOperator = false; + } else { + System.out.println("Please enter the correct letter"); + } + break; + } while (!wrongOperator); + } + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } else { + System.out.println("Please enter the correct letter"); + } } + } } - - } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class index 54f685ae2ea990e557549c79cd4b1e8f5a2c6805..40f9ecb1aaa4f1de3f3734ab186c14ae44902c31 100644 GIT binary patch literal 1057 zcmbW0OK;Oa5Xb*pJ8>J_CVlaKlv1c2pau>g2=qXsN=OkPrOJJ?UcweXqK#byUkbsY zAP#&0J``fssrm>$MEI~fv!367W_Ik~e}4V~u#KRG8CVW%7Zp?)8vFc!2N6#O!JGcR z6d6PHxk^;F&0u+cZw|AVb5L_}4(^%o?x#^EV~R?1f>t|)kV=EMS|wRG(~`%n8qo_b z>S!>`M=FtBIpmsWsb*O5{4rA`CqN|w0+z7sV8z8M&Yw+J1WrP<~WVOyy;15{!hBNv7T@A$TP6 z$TSn|q+0G$Rk@ZU278APhI)q@ex1jCsrPt4qLZagN>Gn$W&EQ~3+<=bje=c+W!@jL#=3*eLeGXrmPNK-rY9!#np5jF%k(}>>OGiR?{1l1I;r<~ vYQ1~Mm;a*ZAEcog@GOW*nn=JmZE literal 729 zcmbV|%TB^T6o&t?g(9L{ye>5{5m;Dtp)nd3LRb-9XxLAuBM!D5Q(8=XDdWn-g%99E z8P8M_31LB;#ktM=-KX6CJy49m}rdNgB%$gWVBoX?@YJfc1Wy)Og%v782 zU~d#Gp-9$TgQ69(rQZkSS1DsyLz%1*U%@66U>`IFujHq-`jmUp@^Z!6o>_7AF1aNz&| diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayWork.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayWork.class index 63a927413c660088ce5fe0e01e9d3fe36fd0c5b1..bd2710bdb7ae63fb93dcf5b17bf46f272cd8642a 100644 GIT binary patch literal 7538 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 literal 6126 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 Date: Sun, 26 Jun 2022 19:11:05 -0400 Subject: [PATCH 27/46] Whats up --- .DS_Store | Bin 6148 -> 6148 bytes 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/Console.java | 330 ++++++++++++++---- .../scientificcalculator/CoreFeatures.java | 34 +- .../scientificcalculator/DisplayWork.java | 270 -------------- .../scientificcalculator/MainApplication.java | 62 +--- .../ScientificFeatures.java | 31 +- src/out/.DS_Store | Bin 0 -> 6148 bytes src/out/production/.DS_Store | Bin 0 -> 6148 bytes src/out/production/main/.DS_Store | Bin 0 -> 6148 bytes src/out/production/main/com/.DS_Store | Bin 0 -> 6148 bytes .../main/com/zipcodewilmington/.DS_Store | Bin 0 -> 6148 bytes .../ScientificFeaturesTest.java | 10 + 16 files changed, 295 insertions(+), 442 deletions(-) delete mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/DisplayWork.java create mode 100644 src/out/.DS_Store create mode 100644 src/out/production/.DS_Store create mode 100644 src/out/production/main/.DS_Store create mode 100644 src/out/production/main/com/.DS_Store create mode 100644 src/out/production/main/com/zipcodewilmington/.DS_Store diff --git a/.DS_Store b/.DS_Store index da23850804c380aefa471bf2829a2f90da11e9af..4092bab25c427ff270123ef7d6da4ec9af935d3c 100644 GIT binary patch delta 240 zcmZoMXfc=|#>B)qu~2NHo}wr#0|Nsi1A_nqLj^-FLyl)oesWUI=8ufa8S6n(>B`mu~2NHo}wrd0|Nsi1A_oVaY0f}eiD$kBdK6w;qu7_A}o`qGPR2s zo0#b+7+ILs>L^rO8X4#)m>3#wHekNavaz9!aWgvyKL^mT&5g|8nJ4p$SaJXj0GY?M JIY49!GXTe88ZZC= diff --git a/src/.DS_Store b/src/.DS_Store index b235d031ebcdbe723504fe52fc29c59e6bc4d3a9..bfe0f3b3e97226b1b1ad2b14fdb76f5bf30e7686 100644 GIT binary patch delta 282 zcmZoMXfc=|#>B!ku~2NHo}wrx0|Nsi1A_pAXHI@{QcivnkT07>WFDp-5fe)z9R(u`gIXPhYD*&n9R(9JlgVqCytSDb@)=4Q zO3(~gk8A*t4OTVzA5#-9gN&`A29*UD<>ln(r2{nq9S(G12}3GFF}ekevd9)}{=&4A haWgvyKL^m~K;M05p3E=e$N|*P1XRYbIYML&GXT>7Nt6Hp delta 95 zcmZoMXfc=|#>B)qu~2NHo}wrV0|Nsi1A_oVQh9MfQcivnkiTPN;c`YsmdPe8J(F*- vc~0hJ726!hwvBOPLlpC7b`E|Hp!Usz9N(EI^NTog05yP2VA&iYvW6J|Y(Eya diff --git a/src/main/.DS_Store b/src/main/.DS_Store index cef2a3054957ff9008599d752e8fdca5c0ef0a29..559f94ec934636cac68ee4a6b705e7eea12b6543 100644 GIT binary patch delta 193 zcmZoMXfc=|#>B)qu~2NHo}wrV0|Nsi1A_pAXHI@{QcivnkT0;Ak!d-jCP<2fA&ViA zp^PCBSsEzr2*i5-!GM8bG7n>qh>4|cSR-r5`txj-W_ y8S)tPfMhO14w_Nx5k>*+-OI9>or9kP=s+OnJM(0I5larB`+$gnVRL}U7G?lswl9VN delta 113 zcmZoMXfc=|#>B`mu~2NHo}wrd0|Nsi1A_oVQh9MfQcivnkiTPM;qu7_A}o{5nL0&` zP0Vx@j4VuRbrh;CjSO@YObm@DUt#jz9KyVrWn)7u<7Rdaeh#34n**7@Gf(ChvE%?6 N0WyB)qu~2NHo}w@_0|Nsi1A_oVesWSyeiD!;u=yk7N=9{%1T#Z2Lq0>U zXAVLVDC!8rdjG+IfnhQaW0#1DrIC(;k%d96jzYDik%5kaiJ8gfRgC7Wo7p+|Ie?Y{ Yjr`6$nP0?`185fzF)(Zn5ZS^E06h{RhyVZp delta 109 zcmZoMXfc=|#>B`mu~2NHo}wrd0|Nsi1A_oVaY0f}eiD$kBdK6w;qu7_A}o_lnc78+ zP0Vx@j4VuRbrh;CjSO@YObm@TUtlt4-PoYUxS5@Up95&vW<}=j%#-;=EIEJ%fXrjs J93ZlV833FB84v&f diff --git a/src/main/java/com/.DS_Store b/src/main/java/com/.DS_Store index dcc8c32abffd65cc5b670a4f899ad32cbd80d79c..e5728caac16332d0f4d46acba58d84c7841e0617 100644 GIT binary patch delta 82 zcmZoMXfc@J&&a$nU^gQp^JE?-H5t#G{N$vZ{3Hej1_2;;1Y*7aV8FltRIp6M#L`Gd f!N|g(R!5=Q(#SwZ!NkmD^D(CXESuRm{_+C=*3}q< delta 54 zcmZoMXfc@J&&aefU^nAr0}+UJGvH{=jS+H?D3 zxbjQ*JMA0WAZXwU5t@<4Z*0%ok7vstM5KC?WS6K(L;;+!)z09F&uyHyEFB?ZlWYzKsX*X*!(to9_=zUJlZHIJSf| z86xHDmo!hzv}Y!HQdn-}I)X;f=r=cKv+jPUr8^(m^Om0NciJu8-RsWhjbLMI=i}%8 z&+J!je%r4nh52gjoyS}FgWyp;E~9atnfyEYnOny^A5uZ(e>z>E@4il`iirZEfGDtZ z3ivfJSYNs?lMfOFM1hx9fY%2NXAC`74(-x`!d?M@e2lb)n2(Fh(H=vOl|%Hvl%oP2 zRrxE1a&)w7pBH+p96CBFfB8`U&C1_Ulzls%uWdT1(4mx~fGF@#ffZM6^8SDP^!@)K zNot~iDDbKjQ1zqesE1$jd+Wl_@m{Op=WsU8s~p}@5ZJ94xx5u`!mXiQa{vrIRu0hu PlY@YjK?+geSrzyP>Q`ss literal 0 HcmV?d00001 diff --git a/src/out/production/.DS_Store b/src/out/production/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..24fb67db013b1a5ccaeaaf23eb4bbf399ccb2cde GIT binary patch literal 6148 zcmeHK!AiqG5Z!I7O({YT3Oz1(EgDM^i&~z_Tl{J_}jG^Z+igESdsuKUId#nRe(*(p0! z=O%bilOPMT@yHK{SNL?UR2t3aVRVu7Cf(ZRv65Ms$lg!~BykU1t}hcAtBJ41G9KyJ zz$`cwr_!y}r_)xu*$~YGch(TocGGQ$)_!X?t2kTRyN74p$Fwiiv!R~Dcd2E=;v8OJ zvdHHt7|K-1d$7&@=YE9505L!etRe&Uu5+rZm>lIq3=jjqVgT<40gC8Z%njW%H zaG~89_YBfV3=jjK8Nl8Tq=xnX;923yOk% nxxqyUOmry*Uo6FSP%U5=I05u5<_5t6LO%kU1{#QgKV{$pmoZej literal 0 HcmV?d00001 diff --git a/src/out/production/main/.DS_Store b/src/out/production/main/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..6caecfdde0e7a8a13141bd3226db6a845211f284 GIT binary patch literal 6148 zcmeHK!AiqG5Z!I7O(;SR3OxqA7LBEd#Y>F!;MIs8RBF-`4W`-Br1nq>IqMJkCH{`i z>~4foy?78TGcfx$vojm!ZP>{$#<(|)4j8i-V+JT<#f0G-!FALXsc1_TkmDX=5GEpo zC)|$YKQMr2S7iex*yuc2I=>TG+53nQzA_L-R2rjqRaT%2*>9$*T`^Z_e?0L8CwCv7dXR$Dio!$N8i~dtGO2vyJp2IgOWlLiTuQ1Ws zJo}S05$OY1O7GH(kQg8ah=KKGK;L*qV|`Pk%!mPE;Fk>G{a}M4x*7|G^6G#=wg7-N zFiU~C{P_p8(E#XbEEIwTgsV_M70Pvs!FBJzRXD7>+P_e!!WoxuhJEy#x$aQ7Zaugy z-5GZk(nt&t1Ir9x?+0RG{XhG;|CdfQ5Cg=(dNROkJ-_EcZo0OvWQn!b2E7MGLBB%b lR|rgGDF$CG#Z6EtV7GAs=xQt!f(3+r1SAbK5Ceb8z$e}kQqTYZ literal 0 HcmV?d00001 diff --git a/src/out/production/main/com/.DS_Store b/src/out/production/main/com/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..e5728caac16332d0f4d46acba58d84c7841e0617 GIT binary patch literal 6148 zcmeHK!D`z;5S?}0MkW+oXduUhTutj3QyO|v-Q>_~71Bdn94j)ZsIqHpxq=vj&dm?y zOY%GIo85J2aRNCNQ)XcHjb>*?(p#~sAtE)HX9q-WB8s4ljTVM`gy&h;q!Bz@K;>#! z%4kd#?!WFY zm#t`b|JB=%!|%nVu|M6rkixg@f9m zD4!0$4smh7+M`b=6`Btf?yN$GqTJn4U%PNpu}2w&0b$^82DtZwwE6r$ez^a4K{5yf z!odH@fNCBkM+3ZDI9u1=lFwQVJ%h4vTZ>ePB literal 0 HcmV?d00001 diff --git a/src/out/production/main/com/zipcodewilmington/.DS_Store b/src/out/production/main/com/zipcodewilmington/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..571c6e98d3f19492a455d99c6a1ed68c0b3a99ca GIT binary patch literal 6148 zcmeHK!A{#i5S~1PhiUb!xXhxcSRPZCtOwtt3p0(%xSSNdcznW7pN+|qg&ikf($Tcv z-276G0_Wh^+kL+h|uIw9;!gpAPhVQ z1O6-u)}Lc>SyLDg23|A+d_HI>W9YGRXpasIwgmvz;kE*se+@ZDdkj5R4lx5!E*0of zm2WYWONU?kxX@$e(4~{|&4=8D5EeS4BTaadp}5%@BgFw`+plG zgD@ZryiNvG{V+Q0;obb*y7ZQO*J|h~l!fCehyPMw*sB<^d=+m)t-!C@0EQkbhwwn; ON5Ik`gD~)<4BP-V+GryH literal 0 HcmV?d00001 diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java index 90ab970..9a85195 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java @@ -121,6 +121,16 @@ void TestInverseLn() { Assertions.assertEquals(148.41315910257657,inverseNaturalLogT); } + @Test + void TestCubeRoot() { + + } + + @Test + void TestCube(){ + + } + From fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 Mon Sep 17 00:00:00 2001 From: Thina Date: Sun, 26 Jun 2022 19:39:04 -0400 Subject: [PATCH 28/46] cleaned up --- pom.xml | 4 + .../scientificcalculator/Console.java | 305 ++++++------------ 2 files changed, 103 insertions(+), 206 deletions(-) diff --git a/pom.xml b/pom.xml index e7cb4f6..709a27c 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,10 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + 18 + 18 + \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 667bcc0..85cf50e 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -41,32 +41,94 @@ public void calcRun() { firstNumber = Calculator.nextDouble(); // Attempt to handle the error, but need a try/catch - if (firstNumber != answer) { - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - Console reRun = new Console(); - clear.clear(); - reRun.calcRun(); - wrongOperator = false; - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (wrongOperator); - // print calculator choice - System.out.print("Enter math operator to use for this calculation "); - operator = Calculator.next(); + // print calculator choice + System.out.print("Enter math operator to use for this calculation "); + operator = Calculator.next(); + + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); - // Attempt to handle the error, but need a try/catch - if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || - !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || - !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { + + switch (operator) { + case "+": + CoreFeatures additionFormula = new CoreFeatures(); + String additionFormulaRead = String.valueOf(additionFormula.add(firstNumber, secondNumber)); + System.out.println(additionFormulaRead); + break; + case "-": + CoreFeatures subtractionFormula = new CoreFeatures(); + String subtractionFormulaRead = String.valueOf(subtractionFormula.subtract(firstNumber, secondNumber)); + System.out.println(subtractionFormulaRead); + break; + case "/": + CoreFeatures divisionFormula = new CoreFeatures(); + String divisionFormulaRead = String.valueOf(divisionFormula.div(firstNumber, secondNumber)); + System.out.println(divisionFormulaRead); + break; + case "*": + CoreFeatures multiplyFormula = new CoreFeatures(); + String multiplyFormulaRead = String.valueOf(multiplyFormula.mult(firstNumber, secondNumber)); + System.out.println(multiplyFormulaRead); + break; + case "**": + ScientificFeatures squareFormula = new ScientificFeatures(); + String squareFormulaPrint = String.valueOf(squareFormula.square(firstNumber)); + System.out.println(squareFormulaPrint); + break; + case "***": + ScientificFeatures cubeFormula = new ScientificFeatures(); + String cubeFormulaPrint = String.valueOf(cubeFormula.cubeRoot(firstNumber)); + case "+/-": + String switchSignFomrulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); + System.out.println(switchSignFomrulaRead); + break; + case "*/": + ScientificFeatures squareRootFormula = new ScientificFeatures(); + String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); + System.out.println(squareRootFormulaPrint); + break; + case "inverse": + ScientificFeatures inverseFormula = new ScientificFeatures(); + String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); + System.out.println(inverseFormulaRead); + break; + case "sine": + ScientificFeatures sineFormula = new ScientificFeatures(); + String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); + System.out.println(sineFormulaRead); + break; + case "cos": + ScientificFeatures cosineFormula = new ScientificFeatures(); + String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); + System.out.println(cosineFormulaRead); + break; + case "tan": + ScientificFeatures tanFormula = new ScientificFeatures(); + String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); + System.out.println(tanFormulaRead); + break; + case "invsine": + ScientificFeatures arcSine = new ScientificFeatures(); + String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); + System.out.println(arcSineRead); + break; + case "invcosine": + ScientificFeatures arcCosine = new ScientificFeatures(); + String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); + System.out.println(arcCosineRead); + break; + case "invtangent": + ScientificFeatures arcTan = new ScientificFeatures(); + String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); + System.out.println(arcTanFormula); + break; + case "fac": + ScientificFeatures factorialFormula = new ScientificFeatures(); + String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); + System.out.println(factorialFormulaRead); + break; + default: System.out.println("Incorrect operator"); do { System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); @@ -74,198 +136,29 @@ public void calcRun() { if (inputEscRead.equalsIgnoreCase("Y")) { onButton = false; } else if (inputEscRead.equalsIgnoreCase("N")) { - Console reRun = new Console(); clear.clear(); - reRun.calcRun(); + wrongOperator = false; } else { System.out.println("Please enter the correct letter"); } break; } while (!wrongOperator); - - // check if the operator sees a sign - if (operator.equalsIgnoreCase("+/-")) { - String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); - switchSignFormulaHolder = switchSignFomrulaRead; - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - } - System.out.println("Enter math operator to use for this calculation (if another negative number, please enter +/- again)"); - operator = Calculator.next(); - // Need a try catch method - if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || - !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || - !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (!wrongOperator); - } - // operator sees a sign - if (operator.equalsIgnoreCase("+/-")) { - String switchSignFormulaReadSecond = String.valueOf((int) switchSignFormula.switchSign((secondNumber))); - switchSignFormulaHolderNegSecond = switchSignFormulaReadSecond; - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - // operator types in a plus, additoin - if (operator.equalsIgnoreCase("+")) { - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(additionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); - } - - } else if (operator.equalsIgnoreCase("-")) { - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(subtractionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - } else { - System.out.println("Please enter the correct letter"); - } - } - } - } else { - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - } - - - switch (operator) { - case "+": - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); - System.out.println(additionFormulaRead); - break; - case "-": - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); - System.out.println(subtractionFormulaRead); - break; - case "/": - CoreFeatures divisionFormula = new CoreFeatures(); - String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); - System.out.println(divisionFormulaRead); - break; - case "*": - CoreFeatures multiplyFormula = new CoreFeatures(); - String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); - System.out.println(multiplyFormulaRead); - break; - case "**": - ScientificFeatures squareFormula = new ScientificFeatures(); - String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); - System.out.println(squareFormulaPrint); - break; - case "***": - ScientificFeatures cubeFormula = new ScientificFeatures(); - String cubeFormulaPrint = String.valueOf((int) cubeFormula.cubeRoot(firstNumber)); - case "+/-": - String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); - System.out.println(switchSignFomrulaRead); - break; - case "*/": - ScientificFeatures squareRootFormula = new ScientificFeatures(); - String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); - System.out.println(squareRootFormulaPrint); - break; - case "inverse": - ScientificFeatures inverseFormula = new ScientificFeatures(); - String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); - System.out.println(inverseFormulaRead); - break; - case "sine": - ScientificFeatures sineFormula = new ScientificFeatures(); - String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); - System.out.println(sineFormulaRead); - break; - case "cos": - ScientificFeatures cosineFormula = new ScientificFeatures(); - String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); - System.out.println(cosineFormulaRead); - break; - case "tan": - ScientificFeatures tanFormula = new ScientificFeatures(); - String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); - System.out.println(tanFormulaRead); - break; - case "invsine": - ScientificFeatures arcSine = new ScientificFeatures(); - String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); - System.out.println(arcSineRead); - break; - case "invcosine": - ScientificFeatures arcCosine = new ScientificFeatures(); - String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); - System.out.println(arcCosineRead); - break; - case "invtangent": - ScientificFeatures arcTan = new ScientificFeatures(); - String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); - System.out.println(arcTanFormula); - break; - case "fac": - ScientificFeatures factorialFormula = new ScientificFeatures(); - String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); - System.out.println(factorialFormulaRead); - break; - default: - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - wrongOperator = false; - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (!wrongOperator); - } - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); - } - } - } - + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } else { + System.out.println("Please enter the correct letter"); + } } + } +} // From 3564a8e1b7732f92c065b952edc27351b3edcd8d Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 19:45:57 -0400 Subject: [PATCH 29/46] last do while loop removed --- .../scientificcalculator/Console.java | 323 ++++++------------ .../scientificcalculator/CoreFeatures.java | 41 --- .../scientificcalculator/Console.class | Bin 2831 -> 5710 bytes .../scientificcalculator/CoreFeatures.class | Bin 1057 -> 1057 bytes .../scientificcalculator/DisplayWork.class | Bin 7538 -> 0 bytes .../MainApplication.class | Bin 2154 -> 648 bytes .../ScientificFeatures.class | Bin 2763 -> 2597 bytes .../CoreFeaturesTest.class | Bin 1302 -> 1309 bytes .../ScientificFeaturesTest.class | Bin 3751 -> 3797 bytes .../CoreFeaturesTest.java | 4 +- .../ScientificFeaturesTest.java | 4 +- 11 files changed, 112 insertions(+), 260 deletions(-) delete mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/DisplayWork.class diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 667bcc0..54844fe 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -19,8 +19,12 @@ public class Console { public void calcRun() { + // While loop initiation onButton = true; + String operator; + + // Objects Scanner Calculator = new Scanner(System.in); ScientificFeatures switchSignFormula = new ScientificFeatures(); Scanner inputEsc = new Scanner(System.in); @@ -41,230 +45,119 @@ public void calcRun() { firstNumber = Calculator.nextDouble(); // Attempt to handle the error, but need a try/catch - if (firstNumber != answer) { - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - Console reRun = new Console(); - clear.clear(); - reRun.calcRun(); - wrongOperator = false; - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (wrongOperator); - // print calculator choice - System.out.print("Enter math operator to use for this calculation "); - operator = Calculator.next(); + // check if the operator sees a sign + System.out.println("Enter math operator to use for this calculation"); + operator = Calculator.next(); + - // Attempt to handle the error, but need a try/catch - if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || - !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || - !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + + // switch operator for the operators + switch (operator) { + case "+": + CoreFeatures additionFormula = new CoreFeatures(); + String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); + System.out.println(additionFormulaRead); + break; + case "-": + CoreFeatures subtractionFormula = new CoreFeatures(); + String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); + System.out.println(subtractionFormulaRead); + break; + case "/": + CoreFeatures divisionFormula = new CoreFeatures(); + String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); + System.out.println(divisionFormulaRead); + break; + case "*": + CoreFeatures multiplyFormula = new CoreFeatures(); + String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); + System.out.println(multiplyFormulaRead); + break; + case "**": + ScientificFeatures squareFormula = new ScientificFeatures(); + String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); + System.out.println(squareFormulaPrint); + break; + case "***": + ScientificFeatures cubeFormula = new ScientificFeatures(); + String cubeFormulaPrint = String.valueOf((int) cubeFormula.cubeRoot(firstNumber)); + case "+/-": + String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); + System.out.println(switchSignFomrulaRead); + break; + case "*/": + ScientificFeatures squareRootFormula = new ScientificFeatures(); + String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); + System.out.println(squareRootFormulaPrint); + break; + case "inverse": + ScientificFeatures inverseFormula = new ScientificFeatures(); + String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); + System.out.println(inverseFormulaRead); + break; + case "sine": + ScientificFeatures sineFormula = new ScientificFeatures(); + String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); + System.out.println(sineFormulaRead); + break; + case "cos": + ScientificFeatures cosineFormula = new ScientificFeatures(); + String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); + System.out.println(cosineFormulaRead); + break; + case "tan": + ScientificFeatures tanFormula = new ScientificFeatures(); + String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); + System.out.println(tanFormulaRead); + break; + case "invsine": + ScientificFeatures arcSine = new ScientificFeatures(); + String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); + System.out.println(arcSineRead); + break; + case "invcosine": + ScientificFeatures arcCosine = new ScientificFeatures(); + String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); + System.out.println(arcCosineRead); + break; + case "invtangent": + ScientificFeatures arcTan = new ScientificFeatures(); + String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); + System.out.println(arcTanFormula); + break; + case "fac": + ScientificFeatures factorialFormula = new ScientificFeatures(); + String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); + System.out.println(factorialFormulaRead); + break; + default: System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - Console reRun = new Console(); - clear.clear(); - reRun.calcRun(); - } else { - System.out.println("Please enter the correct letter"); - } break; - } while (!wrongOperator); - - // check if the operator sees a sign - if (operator.equalsIgnoreCase("+/-")) { - String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); - switchSignFormulaHolder = switchSignFomrulaRead; - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - } - System.out.println("Enter math operator to use for this calculation (if another negative number, please enter +/- again)"); - operator = Calculator.next(); - // Need a try catch method - if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || - !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || - !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (!wrongOperator); - } - // operator sees a sign - if (operator.equalsIgnoreCase("+/-")) { - String switchSignFormulaReadSecond = String.valueOf((int) switchSignFormula.switchSign((secondNumber))); - switchSignFormulaHolderNegSecond = switchSignFormulaReadSecond; - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - // operator types in a plus, additoin - if (operator.equalsIgnoreCase("+")) { - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(additionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); - } + } - } else if (operator.equalsIgnoreCase("-")) { - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(subtractionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - } else { - System.out.println("Please enter the correct letter"); - } - } - } - } else { - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - } + // Exit and restart + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + Console reRun = new Console(); + reRun.calcRun(); + } else { + System.out.println("Please enter the correct letter"); + } + } + } +} - switch (operator) { - case "+": - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); - System.out.println(additionFormulaRead); - break; - case "-": - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); - System.out.println(subtractionFormulaRead); - break; - case "/": - CoreFeatures divisionFormula = new CoreFeatures(); - String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); - System.out.println(divisionFormulaRead); - break; - case "*": - CoreFeatures multiplyFormula = new CoreFeatures(); - String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); - System.out.println(multiplyFormulaRead); - break; - case "**": - ScientificFeatures squareFormula = new ScientificFeatures(); - String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); - System.out.println(squareFormulaPrint); - break; - case "***": - ScientificFeatures cubeFormula = new ScientificFeatures(); - String cubeFormulaPrint = String.valueOf((int) cubeFormula.cubeRoot(firstNumber)); - case "+/-": - String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); - System.out.println(switchSignFomrulaRead); - break; - case "*/": - ScientificFeatures squareRootFormula = new ScientificFeatures(); - String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); - System.out.println(squareRootFormulaPrint); - break; - case "inverse": - ScientificFeatures inverseFormula = new ScientificFeatures(); - String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); - System.out.println(inverseFormulaRead); - break; - case "sine": - ScientificFeatures sineFormula = new ScientificFeatures(); - String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); - System.out.println(sineFormulaRead); - break; - case "cos": - ScientificFeatures cosineFormula = new ScientificFeatures(); - String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); - System.out.println(cosineFormulaRead); - break; - case "tan": - ScientificFeatures tanFormula = new ScientificFeatures(); - String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); - System.out.println(tanFormulaRead); - break; - case "invsine": - ScientificFeatures arcSine = new ScientificFeatures(); - String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); - System.out.println(arcSineRead); - break; - case "invcosine": - ScientificFeatures arcCosine = new ScientificFeatures(); - String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); - System.out.println(arcCosineRead); - break; - case "invtangent": - ScientificFeatures arcTan = new ScientificFeatures(); - String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); - System.out.println(arcTanFormula); - break; - case "fac": - ScientificFeatures factorialFormula = new ScientificFeatures(); - String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); - System.out.println(factorialFormulaRead); - break; - default: - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - wrongOperator = false; - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (!wrongOperator); - } - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); - } - } - } - } - } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java index f8eeebe..8bedec5 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java @@ -32,45 +32,4 @@ public void clear() { System.out.println(System.lineSeparator().repeat(100)); } -// public static void main(String args[]) { -// -// double firstNumber; -// double secondNumber; -// double answer = 0; -// String operator; -// -// Scanner Calculator = new Scanner(System.in); -// -// System.out.println("\\\\CALCULATOR\\\\"); -// -// System.out.println("Enter first number"); -// firstNumber = Calculator.nextDouble(); -// -// System.out.println("Enter math operator to use for this calculation"); -// operator = Calculator.next(); -// -// System.out.println("Enter second number)"); -// secondNumber = Calculator.nextDouble(); -// -// switch (operator) { -// case "+": -// answer = firstNumber + secondNumber; -// break; -// case "-": -// answer = firstNumber - secondNumber; -// break; -// case "/": -// answer = firstNumber / secondNumber; -// break; -// case "*": -// answer = firstNumber * secondNumber; -// break; -// default: -// System.out.println("Incorrect operator"); -// break; -// } -// -// System.out.println(answer); -// } -//} } \ No newline at end of file diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index a7e1a728fe4950bf0fdbf13ab307b05874ab2019..13a5bb926fa836571eaa5adc4430fde78c42d49e 100644 GIT binary patch literal 5710 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 L_&2o&@ZNs`ViMM% literal 2831 zcmb7`e|OVl6vw|$yDeRob+Ex0KP?kz*C7Q25sQGVOa>hw#UbLaEDc>)nw0zi=R4pP z=_;8Fkg)%XfLexD?CK{COev-C-N@8{n8z4v+2KmUIAJAl*Zs>mU)U_iql zh6Fa<(eLRsTX#COE6aCGBM=xmWjR)GS|DGUSsF$G!wOUlBhUnn8g94tjny;Uwt3&O zyOz@lT&Lz6mgxl6ZObrp+X!tvaJ|}`>-es166l$JXp<}&DvB6Wut~#aj0+Ukqc7^g ziok$>*Q4P;r7_bO`r|LA%)enwVw-{~4coEfg_K)seqeT)sT8+G^EOvb+Gv#p>UC}Uus=&6czG_lRLl16P!HN_$ z(4D{+IFJz{;iVH)*};Pv-ohb)!6-d}N``Azc1sEl3v7;L2?NWnwWNloCp&Uf!`nC} zkh7#R{W=z$Uie&k6*asg2knHwR1%WiNt;Od3OFena7dchHJrlx0tLtXI%rxB$7f3= zqbknG9A{8qOd4GdyUV6`U0;^tHr{kOg-g0;$@}EtK(Jy_vt!NwKfra)m)>quy-I^) z$;eLFJraK$6&Ufu<-pU8z;Y=>vCB!fdbY)WMGp#c-27-cwsK z^3jyK-5yzrANP}tlohNB?D=m~jznA^w_$-V2!MyRJn^|I za>Z8#ucvuei@pH{t4|<);)5K{@G8Fs9nSKqMe9L)fOEVPm_vhC>3o@>L1|Gf<Zz zss0S*2j0gF`DOy&3kt>~P6>Hwn{edne8Sc+&sCn(4>Q@F4cL=pZ+mU_g-rJ92JD?= z?|NN(*I?>1upf8=gE`A(Q5fA zMmI>e${CtXAxHZy98Fp%(Cj1UlO&7P@)k^NlxB^;0uHB`#XhsxXD;@cy@WYk9V<&w z%f)ZMNAVH1j_-Vo-49WSChz(9<)aavj7IYqOj=>ta+;4oUKCct*m#T~z*cJmRAJi+m1HUArOPw_7EeQ)vL zj|>;@%5fG5T;SebzyvN*mP=8bcz5o=^(gTXjNxM}kv~Ph8+?{yiJ#zR67e8E*V;%xDwIgGb5MKhVdzGz0$Ll;hD#0QRbiH3w{>J_>%u7I=oZ4TEQLI*!~Zhg*w9k diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class index 40f9ecb1aaa4f1de3f3734ab186c14ae44902c31..dce1bc9695456ca0582142741a2c4939db240747 100644 GIT binary patch delta 71 zcmZ3;v5;d!B@-jdMy|=*nEV+9CbKd7Gm1?P1Clb6moY~vDlqUdC;}k^0}lfu UkmP4jVo(Osj10O!l8HeN02TTQ!vFvP delta 71 zcmZ3;v5;d!B@-jpMwQ9inEV;FCbKd7Ga5_|1CnNwmoY~vS~2i3STiUxFfi~i VFak+_1|A%QIrB}AhSP1yXv&M>(pRGdPCt%$rY4fn{0!xAOWRb~sFb!TT$xP7 z8|Sq~lhQlV3LzU~FqYmTt^3V(MP~+mD)8+4`uAHD4b!Ar0wYfcT0u2l9Rf$Eu4%}WmS$% zCK72j6cwEmx#$qr5RQ!b*Q&~yvg$fjRTX-+N~fyY$<*g_;z}n}J+`9DrErCHr#@%CskC6$ZC`5Q^-G99Lg*{55vxRy&rDP(6O&6(3Ty}FgEdOJ%~kU->}ut}^K8t*Y;vwCoSNHx>=Fxe8T2!` zuVj*{<_v4$e1Y29gtI!)=By0I(@r|!L|4VqlN|5)U5T_<+M<;^O*wNVCc;kb?RuSY zqz3bC)M0^uN2)H+ucGqUG-F{Q6<+McMObWNiH)VWxO+lS>4>5z>C>E=*%)VlO(mtj zf_&WD*Er)`FU{ljq8wox%Ve(YqjZ$wdK*zGF=e8h-xjyfC@`$s{v_M7#%YeG89NqY z0w-#>wS?16Ih)Dtw=tX=6y0MfC!2m{^jToub(52FgDp1VNHE3gt@PM{J^&_Gas!ug z10f437Go{6v8cANl1Z_Ows14qmFKlgd$-uQ6}M5GPyC#{qPCLEx(MrS+>UQ?zV>i)TXbH7+{nyc zeR~JJu1%Iw=R}t3lDl`=xLb19)?J#svSWjdjk3cC$5Sh%;lC|Vf4qjTh&4Fjc!GXR zI`L>Db0Nb~2U;$0qbdgJ94Fiuj>VZ8?iHv$&Xv6QF77k2*~Wk2d)=6u4OU-km?NR81tmU}h#t+aze=*CGt`)U3w}mYN(|Qj`ryFDcZA4mlfG!)nbjIMNC!Z&C&4V`n zTLnf#b6cuOYVac)4@(WK?CB!C{bL)CVmpP*BTZ9z=b(lal`}2u(2SD#)50!F$vF$V z1qw(e%|AKmPi#D)w#8FQwx6`|lx%zCK_$udjE!d{*$kc1rRZlip40qOXNJt|Qk54Z z@m`d4tL=qua^Np)?7(fZw%5j$y7ns@yL9bk8`tXED>i;3mGDtjxq&(cjvVz{8?Q-u zVMabx9SE}L4I6LDo}x_80(}a|uD5NxBegBaoif~=wp8(KPOPcDAgoe%V0MBDVqutv z5!)G|C*2fdw4X8iI4&Apu67eimt>TgjL{U6H>GK*$oy!SEGo|47k@CiS}6IOTdMRJSq7YCRt_1+P%R_Sn)_sq z&q0d2v@$!>k(Wc1bZcvjmnT9FP?T@zUNfAG$ar9MWNKPoz?O~&#z(HM`wX@j5xRqw z-0c2bOyorUdW!TER`zzsV`pma4ThxCmxivd4>Wg4SE6L7%_B{7pK8>l!;uwp!mXJA z^VTKWl9A~2n7lptyM)d-dBJ52%NH}iGXk{5eb zG6rEl;CF0I<#@ihp`>aD59@%r9R=#Q_+bTom%l}D^S2K?@Nsb)zh}$VgRmd(u_fd! zMNe2fipbG`^%@t&9G@xA&}AoTr1Z>AoLx1h6X$HlG!`>AVUZNi$$;mv40<|oL5&eK0vC2- z(MI^H+*GFn<0!dANrJoK<>FtjF@t?N@r|I_iAV>Eip0>8Mt*u^dy@_W3f44Pe_HOHAx94!fno2&ktM25< zSXbE6x_4%+YgPprV#RWa|IF`}gd#=L*=VqW7RMCq#CKQ}v*^V4m2ae1f(0BW$N!L} zX1O=$?P2-RlxWrZN$6HRq!ZgZ;FAJP@JkhgxpLFLSoxvjTX|@1<*ZSR;_FU1RK@yvth3||4+!zOj?Y*=ck-#`^L?hM$t<5` zIgRBXfR33gUxB##Mvflv;d2N48&QTZjF=KC=A++dAm?7_z;KZ5{g$nXD~-TYWtl2u_6KJ3N%7gl=P5pa zqJ4aP%K1#^)5K>jpKW~h@;SuugZNDD&Z}uU5_)jC!*x~`Mj{iEfobAN_5^+8Z-=Wi z3$ufE9`?B6XQ6}@N|-p9g%t&h@~}M$CIc^6tYFV)&Z8QC&@W+~cv?Y9B&0+^?(dcu z1F|EaI&RI5?HlZ?$NqFDp0AOy7VM`G%d?37!TuWYbBQRGh*E`^kwpv$4$z2SO2j~k z7^o1Vvxs0Ys1f@lVvs}(QV5=(>P)Q}92~3>FG<7@i5Mag*q=oV4GxtEKFmeGmZ&m` zDpRP(v#4RgVR_W65+y@6=qS|PS=8|0@I2~ui5ekMBNVDNiy9dmDN&txOCri8qFf>7 zvf9g8Jt{b=M;4P3oyGhr!OA22gzi~ZPL)rD#~$~i$?kuf2tT_{UUuAgmz4b&kFy@& zC8i(zye|zzDc=MKFx3p=C$Yhp!0*84U?^sy3>Uz`BHqZpjuB|YNPaRYM>{V+Yj6Ut zM+MgNQ|diTTAP`$w({fYL!9MNjN^M>HTLke_Gz4k7cn0Da5|3S3^9fu{N|uWT!=Hp zCH(eQ&+qVYOcL#wEUv;i;$}<{>o8T^!LMw0W19F5&J~++p4f_6VkbYKJ%KsmXZ&8a z7xTm${64lH^Th|K6Cd%@)?r-ea$}*Z5Q|);xX3jai(L+uxJF{BD}+m2wnU*OzE@9YxyB4?pfww7Z93 zrMn!f+?81EJ{gy}C*pGV0({ebF|KgeV~u+Su5`EID)$w*+I=Igaj(a?ppU=+~R%}x4QY7>OO#V?t@tG{tUN!1is}dz#X0v+~eto4W1#`=oyYpo=SY% za}vI1cyPZ_h#wdZI*bbZ(4fVQQ}KXtF18u-@Srgt4;f4GBO{K7jdna@tj43pHP~+4 zg-+vM>@e=bE@KNGGj?LP@gyEMp1~8wOW0$)jwg+`@U(FN&lsQJS>rH%Y8=6Hritgx z{&>M0iWf}>zc4HDOY?N>H78-8IR!77v+%OH7{4~dc*U&8t7Z#+YhI4m%xm$wc>~@w z*W)d7Gu}40;2m=t-sPp>_vUlhZ|=i;=F2!>zKK7Yf5rRer}&fkIX>V&SN>uZ<3noz z{%Q@vL2Cp)va0a0brL?YCgPAa6`xvj@HcBdKC_nK@76LLwxT#sO z%eq~-tqsCsZ5D>LMOfB0p)T|;FWJ47*ZV*4LT{42XW;--zd_DrWMpGTM*e7-MP_N4 zNq$tT5hlGJ#UJrLEc$*nkBTA`(DSFMUN3!oG5)N2_wwE21J!$gu_0IUl0}E{7uHO% z)3q2MvS!e$WqLmP)~DyAXUo(qUi#OkX7SOxWuV1i)5kvi562eL!(})~SrPs0!~arN zOfL_@NB9_i`r3z2C@Z0-eQLD;{T#$0_V%T>efX5U{Y;axzfsno9{1rh%1Y_)AU>yT z0KM+R-zghNp9k>;WkGu0$DI`MKSwQ;eM#A1df$hCP&S0VABrQC4J8A7jQk>$(f|DK z5@o~40-xZ=8#v^^P~oC%IGNxRZpucG2SMSXY$Vy>6MZNvCkIYd_8VoTGj=w}!ncLN zUQTK~n0Za}TlWf6SbXCfXx$|WIE$O3Zx&w4JQ!qFxF;zOVkWk$bT7nd(5DkoU>e4 zfI*+bbR9umPE>M~ib?%?jARlY@(-+|R1~W}f99|7Fy@Tr--v<3<=?1LqlTMDnZidO lJBJ+1W8ka*2mnft(m1_ppf@|{3vdBfZ$^Y*+)-0e_)ja4$lL$` diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/MainApplication.class index 5ff1a8ba08880cc13a367b174e22b55178126f97..33187db92d2d0fd3164898dceae50144aba38995 100644 GIT binary patch delta 257 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 delta 430 zcmbQsHI0kw)W2Q(7#JAr7#ufpZDo|?Vqj;`=3&rb5NBjyPRT4|vwr}T1%k~F866oJ z^(QMcD{316`CJT4K$3%j1;{c4vUnI6fusO~5rZ+1W?(R3U<0bqpPbLE?g~=R$G{9E z`GK?mgD8U_SdSRk3^Ax4KA>r)3}!%c%z-M|fV2gWW?-;{nTWl0n7zglg+U;yvhPLzq#R4fR*n+U!M5@r;rrT;|X-#)2a@E;o+D_Tdv^%pc z7Zp&vTfCxz`k=h{h>0mg6GME{2VYEhF&dtHGsYJ$F&h8h%0W(RIw|LR-?w`@@8UT&#O zo0c5;<<@tfH8*|C4Vx9(;xyQ*fgai?+dtfQOOE!r>y@L2&N^2d+M&<`^q@qGJvsrz zTTx7o{J8b6zi)25!hsQmq8zxy3+y)C`TTluSMuABu5w6Bp&kyY@j{Z=X6%?8`F`&Y z!&gp6Ii^pcM|f(BhSfCoPggT?^k{w`g4D0jfHU)qIU+}XI`Z58tKAa!ODL4&hLAUQ z9PQCR#{6|WrqBUyugGAowcN9 z;RFY|aZn|yjpN?+=f+c7HmRmEsHu;eII2S`mWi@g8L&rn9GdR9;zmRaQa6$`Jn9^eI*ypB8;q(12fcz9fMbj+q>|e?z*pF9E_oA3I6$q(a>)%UW3Nct2P6?6>W z+)T8HG<+*=01eX!N<^b*t#CT0D1bkr<}WCC;2JH8Z)l{@EGd1BRM&Q$>I>u5J8?Bs zO|?{qzvZ;l8M~D#xxY7dHCl8UgI9;hP6Z6`W^V(Q<3+&Y*dnN2uuvcT>@6ki6TW>?V4o^yuZO)+WZwsS2kiS{ca*SC`}UIp`>Aqv z81`0?y&HBX>L&fW|AQIY)wY!!A2 z_OTN7jBj5M*sqnd2Vw6M*`u&^*kiDdm#|;=?KcGWo8|2Nun&rC6ZQn`N!V5i`z_yo zTVP)-XCH?BxX7M{eFFAL*r!U^@A&q+0{cDR-hd?Mm+qXm@EK=d_bn`WDg58J;-&I~ PoG&woM3-S#(EI-aXZhCF literal 3751 zcmbuBTWl0%6vxlB+nHqsrrnus zxp)EZx8fBQ6%}~#5ff90CWiRvgD)n$7!6Op8RLtW7>)mLW_EULzimm_O=iDyzH`3c zIp25AxAX14Uw%zQd+ADuDyUMTfJ{{+3RE+qOeoQuq7OxTGb3u&5=h*w>6*1ypvp)~ zzeGWS_GFFG=qYV1YaCN2wcMzt4_SsDHM5$kTiT$O%__NUA*WbIKAQ5BovLCL@~Rmk zi7Lf-J^1)AX^~7}ss_m%FDQ9cpg<(ik`Uv&iY9ebFHwU`OK7P;%|?DGI#NJPc#dh7 znvW`DTC~kH)x4z{x+##X*g^-E%R#J)BoZzCjI>OqyBI0tkopY6V(R5Gt#H(nnw1?+ zX+yer!x!KxneJxulBQ3nc~cG2YHUYGJ|CjBv`(UkOf9tjf4i433Yi>IktUQ}LG2wB zr~yeOOWW%hw1%jT?q!*66lh(uimaNmQoIETn*`>8co;?!9^ao3j-xnQby{ zXET*q!xUq`-unKF#)ivmVwX%0*b|nb!$bXS+r|C2#CVsp%VK=sj6Gte56aX|34s>6 z38w&Y_c0;He!B1Pe{OC>=}7dDOkK=yk!#p)IPv^;es}u2OIMjmw@f|EB+d|I(fqBd!uLHZS>3E5Q!tYHnM+Mc{)ax1ojMUZlv z$*pxKsMwvYkF_PIbD>=>qHo|E$$qgW71FBstlN?jouMudm&&6pU=v)&=cHD~nwpc#cP?B)j>dwJ<^hItBqYau2b~*>KyU7$pS9 zuy}t$(G>+K{ z+c`r4e2E&rBI)2YT9DjOPoZg&yXvVXa-C{R>($zJVG2?;0;r*-wAfy|nJSsTyLJ#W zc{0JPfu%(Sa3(O%qM5`m(TO?PHPh4xc8JGrz=}(3@>1|vUbERJ=VYInla0Kaz+TB? zF9&-C*ej8Da~bw&kNpHE?>Xg=5B9Dy z?B_i8^BndI^Rah=-O6L{0edglF|gxh*e`nQmpJT~J+_KwWj)s9>#;rc6q}|t;5&Hu z1n?br+v>zC;65L|$!oJZdd0@q!SYoO{`!O01-gXRuAs~R E0ne7|bpQYW diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java index 957c963..4c9e95e 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/CoreFeaturesTest.java @@ -30,7 +30,7 @@ void multTest() { @Test void divTest() { - double divT = allTests.div(5, 10); - Assertions.assertEquals(0.5, divT); + double divT = allTests.div(4, 6); + Assertions.assertEquals(0, divT); } } \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java index 9a85195..76c67c3 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java @@ -34,8 +34,8 @@ void TestSwitchSign() { @Test void TestInverse() { ScientificFeatures inverseTest = new ScientificFeatures(); - double inverseT = inverseTest.inverse(0); - Assertions.assertEquals("Err",inverseT); + double inverseT = inverseTest.inverse(5); + Assertions.assertEquals(0.20,inverseT); } From abc88bdbffe819067ee3dce76e4c830ca12e4987 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 19:47:29 -0400 Subject: [PATCH 30/46] cool --- pom.xml | 4 ++ .../scientificcalculator/Console.java | 62 +++++++++++++++++++ 2 files changed, 66 insertions(+) diff --git a/pom.xml b/pom.xml index e7cb4f6..709a27c 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,10 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + 18 + 18 + \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 54844fe..3a99dc3 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -46,6 +46,7 @@ public void calcRun() { // Attempt to handle the error, but need a try/catch +<<<<<<< HEAD // check if the operator sees a sign System.out.println("Enter math operator to use for this calculation"); operator = Calculator.next(); @@ -59,33 +60,69 @@ public void calcRun() { case "+": CoreFeatures additionFormula = new CoreFeatures(); String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); +======= + // print calculator choice + System.out.print("Enter math operator to use for this calculation "); + operator = Calculator.next(); + + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + + + switch (operator) { + case "+": + CoreFeatures additionFormula = new CoreFeatures(); + String additionFormulaRead = String.valueOf(additionFormula.add(firstNumber, secondNumber)); +>>>>>>> fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 System.out.println(additionFormulaRead); break; case "-": CoreFeatures subtractionFormula = new CoreFeatures(); +<<<<<<< HEAD String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); +======= + String subtractionFormulaRead = String.valueOf(subtractionFormula.subtract(firstNumber, secondNumber)); +>>>>>>> fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 System.out.println(subtractionFormulaRead); break; case "/": CoreFeatures divisionFormula = new CoreFeatures(); +<<<<<<< HEAD String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); +======= + String divisionFormulaRead = String.valueOf(divisionFormula.div(firstNumber, secondNumber)); +>>>>>>> fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 System.out.println(divisionFormulaRead); break; case "*": CoreFeatures multiplyFormula = new CoreFeatures(); +<<<<<<< HEAD String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); +======= + String multiplyFormulaRead = String.valueOf(multiplyFormula.mult(firstNumber, secondNumber)); +>>>>>>> fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 System.out.println(multiplyFormulaRead); break; case "**": ScientificFeatures squareFormula = new ScientificFeatures(); +<<<<<<< HEAD String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); +======= + String squareFormulaPrint = String.valueOf(squareFormula.square(firstNumber)); +>>>>>>> fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 System.out.println(squareFormulaPrint); break; case "***": ScientificFeatures cubeFormula = new ScientificFeatures(); +<<<<<<< HEAD String cubeFormulaPrint = String.valueOf((int) cubeFormula.cubeRoot(firstNumber)); case "+/-": String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); +======= + String cubeFormulaPrint = String.valueOf(cubeFormula.cubeRoot(firstNumber)); + case "+/-": + String switchSignFomrulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); +>>>>>>> fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 System.out.println(switchSignFomrulaRead); break; case "*/": @@ -135,30 +172,55 @@ public void calcRun() { break; default: System.out.println("Incorrect operator"); +<<<<<<< HEAD break; } // Exit and restart System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); +======= + do { + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + clear.clear(); + wrongOperator = false; + } else { + System.out.println("Please enter the correct letter"); + } + break; + } while (!wrongOperator); + } + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); +>>>>>>> fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 String inputEscRead = inputEsc.next(); if (inputEscRead.equalsIgnoreCase("Y")) { onButton = false; } else if (inputEscRead.equalsIgnoreCase("N")) { System.out.println("\033[H\033[2J"); System.out.flush(); +<<<<<<< HEAD Console reRun = new Console(); reRun.calcRun(); +======= +>>>>>>> fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 } else { System.out.println("Please enter the correct letter"); } } } +<<<<<<< HEAD } +======= +>>>>>>> fec307c1f392ee6b5b77f8d988e4ba54fa0a37a6 +} // From 3b12a62e698ff6934e4b85a442cfaa1b9b3a60b0 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 20:25:04 -0400 Subject: [PATCH 31/46] please work --- .../scientificcalculator/Console.java | 325 +++++++++--------- 1 file changed, 162 insertions(+), 163 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 667bcc0..e766758 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -7,7 +7,6 @@ * Created by leon on 2/9/18. */ public class Console { - private double answer; private boolean onButton; private double firstNumber; @@ -89,182 +88,182 @@ public void calcRun() { switchSignFormulaHolder = switchSignFomrulaRead; System.out.print("Enter second number "); secondNumber = Calculator.nextDouble(); - } - System.out.println("Enter math operator to use for this calculation (if another negative number, please enter +/- again)"); - operator = Calculator.next(); - // Need a try catch method - if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || - !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || - !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (!wrongOperator); - } - // operator sees a sign - if (operator.equalsIgnoreCase("+/-")) { - String switchSignFormulaReadSecond = String.valueOf((int) switchSignFormula.switchSign((secondNumber))); - switchSignFormulaHolderNegSecond = switchSignFormulaReadSecond; - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - // operator types in a plus, additoin - if (operator.equalsIgnoreCase("+")) { - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(additionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); - } - - } else if (operator.equalsIgnoreCase("-")) { - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(subtractionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - } else { - System.out.println("Please enter the correct letter"); - } + } + System.out.println("Enter math operator to use for this calculation (if another negative number, please enter +/- again)"); + operator = Calculator.next(); + // Need a try catch method + if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || + !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || + !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { + System.out.println("Incorrect operator"); + do { + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + clear.clear(); + } else { + System.out.println("Please enter the correct letter"); } - } - } else { + break; + } while (!wrongOperator); + } + // operator sees a sign + if (operator.equalsIgnoreCase("+/-")) { + String switchSignFormulaReadSecond = String.valueOf((int) switchSignFormula.switchSign((secondNumber))); + switchSignFormulaHolderNegSecond = switchSignFormulaReadSecond; System.out.println("Enter math operator to use for this calculation"); operator = Calculator.next(); - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - } - - - switch (operator) { - case "+": + // operator types in a plus, additoin + if (operator.equalsIgnoreCase("+")) { CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); + String additionFormulaRead = String.valueOf((int) additionFormula.add(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); System.out.println(additionFormulaRead); - break; - case "-": + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } else { + System.out.println("Please enter the correct letter"); + } + + } else if (operator.equalsIgnoreCase("-")) { CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); + String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); System.out.println(subtractionFormulaRead); - break; - case "/": - CoreFeatures divisionFormula = new CoreFeatures(); - String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); - System.out.println(divisionFormulaRead); - break; - case "*": - CoreFeatures multiplyFormula = new CoreFeatures(); - String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); - System.out.println(multiplyFormulaRead); - break; - case "**": - ScientificFeatures squareFormula = new ScientificFeatures(); - String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); - System.out.println(squareFormulaPrint); - break; - case "***": - ScientificFeatures cubeFormula = new ScientificFeatures(); - String cubeFormulaPrint = String.valueOf((int) cubeFormula.cubeRoot(firstNumber)); - case "+/-": - String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); - System.out.println(switchSignFomrulaRead); - break; - case "*/": - ScientificFeatures squareRootFormula = new ScientificFeatures(); - String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); - System.out.println(squareRootFormulaPrint); - break; - case "inverse": - ScientificFeatures inverseFormula = new ScientificFeatures(); - String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); - System.out.println(inverseFormulaRead); - break; - case "sine": - ScientificFeatures sineFormula = new ScientificFeatures(); - String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); - System.out.println(sineFormulaRead); - break; - case "cos": - ScientificFeatures cosineFormula = new ScientificFeatures(); - String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); - System.out.println(cosineFormulaRead); - break; - case "tan": - ScientificFeatures tanFormula = new ScientificFeatures(); - String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); - System.out.println(tanFormulaRead); - break; - case "invsine": - ScientificFeatures arcSine = new ScientificFeatures(); - String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); - System.out.println(arcSineRead); - break; - case "invcosine": - ScientificFeatures arcCosine = new ScientificFeatures(); - String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); - System.out.println(arcCosineRead); - break; - case "invtangent": - ScientificFeatures arcTan = new ScientificFeatures(); - String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); - System.out.println(arcTanFormula); - break; - case "fac": - ScientificFeatures factorialFormula = new ScientificFeatures(); - String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); - System.out.println(factorialFormulaRead); - break; - default: - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - wrongOperator = false; - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (!wrongOperator); - } - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + clear.clear(); + } else { + System.out.println("Please enter the correct letter"); + } + } } + } else { + System.out.println("Enter math operator to use for this calculation"); + operator = Calculator.next(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); } + + switch (operator) { + case "+": + CoreFeatures additionFormula = new CoreFeatures(); + String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); + System.out.println(additionFormulaRead); + break; + case "-": + CoreFeatures subtractionFormula = new CoreFeatures(); + String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); + System.out.println(subtractionFormulaRead); + break; + case "/": + CoreFeatures divisionFormula = new CoreFeatures(); + String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); + System.out.println(divisionFormulaRead); + break; + case "*": + CoreFeatures multiplyFormula = new CoreFeatures(); + String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); + System.out.println(multiplyFormulaRead); + break; + case "**": + ScientificFeatures squareFormula = new ScientificFeatures(); + String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); + System.out.println(squareFormulaPrint); + break; + case "***": + ScientificFeatures cubeFormula = new ScientificFeatures(); + String cubeFormulaPrint = String.valueOf((int) cubeFormula.cubeRoot(firstNumber)); + case "+/-": + String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); + System.out.println(switchSignFomrulaRead); + break; + case "*/": + ScientificFeatures squareRootFormula = new ScientificFeatures(); + String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); + System.out.println(squareRootFormulaPrint); + break; + case "inverse": + ScientificFeatures inverseFormula = new ScientificFeatures(); + String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); + System.out.println(inverseFormulaRead); + break; + case "sine": + ScientificFeatures sineFormula = new ScientificFeatures(); + String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); + System.out.println(sineFormulaRead); + break; + case "cos": + ScientificFeatures cosineFormula = new ScientificFeatures(); + String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); + System.out.println(cosineFormulaRead); + break; + case "tan": + ScientificFeatures tanFormula = new ScientificFeatures(); + String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); + System.out.println(tanFormulaRead); + break; + case "invsine": + ScientificFeatures arcSine = new ScientificFeatures(); + String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); + System.out.println(arcSineRead); + break; + case "invcosine": + ScientificFeatures arcCosine = new ScientificFeatures(); + String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); + System.out.println(arcCosineRead); + break; + case "invtangent": + ScientificFeatures arcTan = new ScientificFeatures(); + String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); + System.out.println(arcTanFormula); + break; + case "fac": + ScientificFeatures factorialFormula = new ScientificFeatures(); + String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); + System.out.println(factorialFormulaRead); + break; + default: + System.out.println("Incorrect operator"); + do { + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + clear.clear(); + wrongOperator = false; + } else { + System.out.println("Please enter the correct letter"); + } + break; + } while (!wrongOperator); + } + System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + System.out.println("\033[H\033[2J"); + System.out.flush(); + } else { + System.out.println("Please enter the correct letter"); + } } } + } +} From ad25dd056e0d8d0e41abe98ad12f79fe91732e04 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 20:28:59 -0400 Subject: [PATCH 32/46] Everything is back to normal --- .../scientificcalculator/Console.java | 116 +----------------- 1 file changed, 6 insertions(+), 110 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index e766758..9add546 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -39,119 +39,15 @@ public void calcRun() { System.out.print("Enter first number "); firstNumber = Calculator.nextDouble(); - // Attempt to handle the error, but need a try/catch - if (firstNumber != answer) { - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - Console reRun = new Console(); - clear.clear(); - reRun.calcRun(); - wrongOperator = false; - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (wrongOperator); - // print calculator choice - System.out.print("Enter math operator to use for this calculation "); - operator = Calculator.next(); + System.out.println("Enter math operator to use for this calculation"); + operator = Calculator.next(); - // Attempt to handle the error, but need a try/catch - if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || - !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || - !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - Console reRun = new Console(); - clear.clear(); - reRun.calcRun(); - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (!wrongOperator); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); - // check if the operator sees a sign - if (operator.equalsIgnoreCase("+/-")) { - String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); - switchSignFormulaHolder = switchSignFomrulaRead; - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - } - System.out.println("Enter math operator to use for this calculation (if another negative number, please enter +/- again)"); - operator = Calculator.next(); - // Need a try catch method - if (!operator.equals("+/-") || !operator.equals("+") || !operator.equals("-") || !operator.equals("/") || !operator.equals("*/") || - !operator.equals("*") || !operator.equals("**") || !operator.equals("fac") || !operator.equals("sine") || !operator.equals("cosine") || - !operator.equals("tan") || !operator.equals("invsine") || !operator.equals("incosine") || !operator.equals("invtangent")) { - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (!wrongOperator); - } - // operator sees a sign - if (operator.equalsIgnoreCase("+/-")) { - String switchSignFormulaReadSecond = String.valueOf((int) switchSignFormula.switchSign((secondNumber))); - switchSignFormulaHolderNegSecond = switchSignFormulaReadSecond; - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - // operator types in a plus, additoin - if (operator.equalsIgnoreCase("+")) { - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(additionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); - } + // Attempt to handle the error, but need a try/catch - } else if (operator.equalsIgnoreCase("-")) { - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(Double.parseDouble(switchSignFormulaHolder), Double.parseDouble(switchSignFormulaHolderNegSecond))); - System.out.println(subtractionFormulaRead); - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); - } else { - System.out.println("Please enter the correct letter"); - } - } - } - } else { - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); - } switch (operator) { @@ -263,7 +159,7 @@ public void calcRun() { } } -} + From aa6d39cafca14316a373e7bff14f5860a2cf1742 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 20:58:21 -0400 Subject: [PATCH 33/46] Added Try Method --- .../scientificcalculator/Console.java | 35 ++++++++++++------ .../scientificcalculator/CoreFeatures.java | 17 ++++----- .../ScientificFeatures.java | 4 -- .../scientificcalculator/Console.class | Bin 5710 -> 5984 bytes 4 files changed, 30 insertions(+), 26 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 9add546..0f2ab96 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -1,6 +1,7 @@ package com.zipcodewilmington.scientificcalculator; +import java.util.InputMismatchException; import java.util.Scanner; /** @@ -24,7 +25,7 @@ public void calcRun() { ScientificFeatures switchSignFormula = new ScientificFeatures(); Scanner inputEsc = new Scanner(System.in); CoreFeatures clear = new CoreFeatures(); - + Console reRun = new Console(); while (onButton) { // loop wrong operator true @@ -37,17 +38,31 @@ public void calcRun() { System.out.println(); // print enter number System.out.print("Enter first number "); - firstNumber = Calculator.nextDouble(); + // try catch method for first number + + try { + firstNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + reRun.calcRun(); + } + System.out.println("Enter math operator to use for this calculation"); + + // try catch method for operator + operator = Calculator.next(); - System.out.println("Enter math operator to use for this calculation"); - operator = Calculator.next(); - System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); + //try catch method for second number + System.out.print("Enter second number "); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); - // Attempt to handle the error, but need a try/catch + } + // Attempt to handle the error, but need a try/catch switch (operator) { @@ -76,9 +91,6 @@ public void calcRun() { String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); System.out.println(squareFormulaPrint); break; - case "***": - ScientificFeatures cubeFormula = new ScientificFeatures(); - String cubeFormulaPrint = String.valueOf((int) cubeFormula.cubeRoot(firstNumber)); case "+/-": String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); System.out.println(switchSignFomrulaRead); @@ -136,7 +148,6 @@ public void calcRun() { if (inputEscRead.equalsIgnoreCase("Y")) { onButton = false; } else if (inputEscRead.equalsIgnoreCase("N")) { - clear.clear(); wrongOperator = false; } else { System.out.println("Please enter the correct letter"); @@ -148,6 +159,7 @@ public void calcRun() { String inputEscRead = inputEsc.next(); if (inputEscRead.equalsIgnoreCase("Y")) { onButton = false; + reRun.calcRun(); } else if (inputEscRead.equalsIgnoreCase("N")) { System.out.println("\033[H\033[2J"); System.out.flush(); @@ -162,7 +174,6 @@ public void calcRun() { - // // public static void print(String output, Object... args) { // System.out.printf(output, args); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java index 8bedec5..924b5a7 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CoreFeatures.java @@ -3,6 +3,12 @@ public class CoreFeatures { + //Addition + public double add(double number1, double number2) { + + return number1 + number2; + } + //Subtraction public double subtract(double number1, double number2) { @@ -10,11 +16,6 @@ public double subtract(double number1, double number2) { return number1 - number2; } - //Addition - public double add(double number1, double number2) { - - return number1 + number2; - } //Multiplication public double mult(double number1, double number2) { @@ -27,9 +28,5 @@ public double div(double number1, double number2) { return number1 / number2; } +} - public void clear() { - System.out.println(System.lineSeparator().repeat(100)); - } - -} \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 12b2bdc..26335b1 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -101,10 +101,6 @@ public double inverseLn(double num1) { return result; } - public double cubeRoot(double num1){ - result = Math.cbrt(num1); - return result; - } } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index 13a5bb926fa836571eaa5adc4430fde78c42d49e..5492299ff5aae4e7a13e996b9a8ea50eb150c4b2 100644 GIT binary patch literal 5984 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 R;EMwPWl7L9x%dS%<3A*7AL;-A delta 3083 zcmZveeSA~Z9mbz~?@4l#d)uU;FWi=vzJ^jL;YBKxi6ZSNFBYK`L_|o_v;^CvP0|)7 z62UPM5T;ka%2e2#-JEX-L<9sjH`&OgP6ACCHOjD;hKrbH|h=$xj)Z_bo&(V{jS`}Pq#$pGS=(q_>%?_K-y^M;E;r4PJ zw_=64&sLTUkXNlDNR3|wElR3V(Jn!*qBcxxtm2*9s58b-TqhqPFeLv2oHUCFLEkQ+#zmUI_E03D;trbC76`gfj--w| zv4M1;wUvUbtg9Pc$CrMWj;~^qxz_GW-mPOZN7Q&vOClBsQqbktqGPL=*Bb8S`d%H| zxn`X`9R!r%>pJek{Sxf)?w&x5elV*PrAzRDj-7l&4feEz7Dl52->u_8Zo1-q;Y4s% zQ@B0Ct30G5e~;yhG8W#9hxzgzF{e02B=_ow;(iW)Q%ASedrU{%>OHQb$Lf7Y$9MS( zwV^zlC>uWOdpe%ve#VeLQ>4a6p4RaUAITgVS!CtMhxY4ujxWpErcof#SUAw3;-Gof zkte0hPaLz|hv^P4<9&7Dqb>os^!v;%p>ZY zVW;Ru7A$KhST=DEf5d;HC`0ZPrjrZ>-RCUDzSvXXccQ(rG^@FB1xVJHgilh6BsD5dc34@HSNyoQ|~&Ht_8Bgd-2Z=v^P>#`~QcmVvdv+8_~ z{j{Mdpp8e`j-crtmX|D|qrMnZQHmKT!))3j7r=)lw9TxbKN{^AM_arf2~5N~Oro8? zM()BCc`c^O+fXY%fNAn>TqEzrbol_Tm5<^&`8ckZPhqBf26ggz)XNtzOa2fIiiFvU z6LSIg8Jom>#g7Hb6f9I`VUf~|W@R}RD=Tr662?-c4>v1GEK@dOxv~|v zD*afY?88dsF|;U8A*dWhtMU>;%FAe1Ud1Zq9fXw&SgpK=4&@R$l|e+915xHeHyef+ zt3aGpBf-X_mrX?Yrou#R=(4z?ES**e_GHemxZv61b;UF;ETVvpl) z_B1xretQo)fi3J5wzAi;jlG3?*;(vh@8Ul8K6bK8*u_4@Zkvn;Z7%fNvhk2@1oqe} z@UX2KkJ`p#AK&Pu_3$Mr$|C#%Z$PC$HM~hDf|KGb!Y|2lQK%Z;B2S}8i|{M*bP86( zugS}xSc~u*@-iu04QI%6Q?&W`E#8KQ0@m;jd0CXM8)wP$Qob5~M_x9iYv3G`ZzG37 z*6@2Wb17m2=LyWCpf&t~yx|nHfj^RGP}mwSke5$U8+ezz0t#HipU4|QaT|D#yg~|H z!~5hFQRIdAfV`0uyoNuMS4^=N;xFWtu({BZ_$!&E6n!B+B(scefQFCAE2sDkTqLi8 zZi0qOUA!4Bj)P$Is|fk9fmO11;d|2;sGE@nQHTbWz= rg`?)h+|q_-Aa{^T^1A<50QeV*$;-bC#~>~83ocDR=QCQHjLZK4MXA$& From fdee8dfb5c9893f00f4c64d16f4f4646c6c30239 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 21:31:46 -0400 Subject: [PATCH 34/46] Finished comments added square root and square test case --- .../scientificcalculator/Console.java | 261 +++++++++--------- .../ScientificFeatures.java | 9 +- .../scientificcalculator/Console.class | Bin 5984 -> 5851 bytes .../scientificcalculator/CoreFeatures.class | Bin 1057 -> 729 bytes .../ScientificFeatures.class | Bin 2597 -> 2698 bytes .../TestMainApplication.class | Bin 938 -> 370 bytes .../ScientificFeaturesTest.class | Bin 3797 -> 4000 bytes .../TestMainApplication.java | 7 - .../ScientificFeaturesTest.java | 11 +- 9 files changed, 139 insertions(+), 149 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 0f2ab96..f642927 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -8,32 +8,29 @@ * Created by leon on 2/9/18. */ public class Console { - private double answer; + private boolean onButton; private double firstNumber; private double secondNumber; - private String switchSignFormulaHolder = ""; - private String switchSignFormulaHolderNegSecond = ""; - private boolean wrongOperator; public void calcRun() { + onButton = true; String operator; Scanner Calculator = new Scanner(System.in); ScientificFeatures switchSignFormula = new ScientificFeatures(); Scanner inputEsc = new Scanner(System.in); - CoreFeatures clear = new CoreFeatures(); Console reRun = new Console(); while (onButton) { // loop wrong operator true - wrongOperator = true; // print for operator choices - System.out.println("For addition, subtraction, division, or multiplication please enter one of these as operator: + - / * "); - System.out.println("For the square, square-root, cube, cube-root, switch-sign or fac, please enter one of these as the operator **(square) */ (squareRoot) +/-(switch sign) fac (factorial)"); - System.out.println("For the inverse, sine, cosine, tan, invsine, incosine or invtangent, please type one of the respective operators."); + System.out.println("Type the function within the ()."); + System.out.println("For addition(+), subtraction(-), division(/), or multiplication(*)"); + System.out.println("For the square(**), square-root(**/), cube(***), cube-root(***/), switch-sign(+/-) or factorial(fac)"); + System.out.println("For the inverse, sine, cosine, tan, invsine, incosine or invtangent, write as they are presented"); System.out.println(); // print enter number @@ -62,140 +59,132 @@ public void calcRun() { } - // Attempt to handle the error, but need a try/catch - - switch (operator) { - case "+": - CoreFeatures additionFormula = new CoreFeatures(); - String additionFormulaRead = String.valueOf((int) additionFormula.add(firstNumber, secondNumber)); - System.out.println(additionFormulaRead); - break; - case "-": - CoreFeatures subtractionFormula = new CoreFeatures(); - String subtractionFormulaRead = String.valueOf((int) subtractionFormula.subtract(firstNumber, secondNumber)); - System.out.println(subtractionFormulaRead); - break; - case "/": - CoreFeatures divisionFormula = new CoreFeatures(); - String divisionFormulaRead = String.valueOf((int) divisionFormula.div(firstNumber, secondNumber)); - System.out.println(divisionFormulaRead); - break; - case "*": - CoreFeatures multiplyFormula = new CoreFeatures(); - String multiplyFormulaRead = String.valueOf((int) multiplyFormula.mult(firstNumber, secondNumber)); - System.out.println(multiplyFormulaRead); - break; - case "**": - ScientificFeatures squareFormula = new ScientificFeatures(); - String squareFormulaPrint = String.valueOf((int) squareFormula.square(firstNumber)); - System.out.println(squareFormulaPrint); - break; - case "+/-": - String switchSignFomrulaRead = String.valueOf((int) switchSignFormula.switchSign(firstNumber)); - System.out.println(switchSignFomrulaRead); - break; - case "*/": - ScientificFeatures squareRootFormula = new ScientificFeatures(); - String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); - System.out.println(squareRootFormulaPrint); - break; - case "inverse": - ScientificFeatures inverseFormula = new ScientificFeatures(); - String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); - System.out.println(inverseFormulaRead); + // switch statement for the operator + switch (operator) { + case "+": + CoreFeatures additionFormula = new CoreFeatures(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + String additionFormulaRead = String.valueOf(additionFormula.add(firstNumber, secondNumber)); + System.out.println(additionFormulaRead); + break; + case "-": + CoreFeatures subtractionFormula = new CoreFeatures(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + String subtractionFormulaRead = String.valueOf(subtractionFormula.subtract(firstNumber, secondNumber)); + System.out.println(subtractionFormulaRead); + break; + case "/": + CoreFeatures divisionFormula = new CoreFeatures(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + String divisionFormulaRead = String.valueOf(divisionFormula.div(firstNumber, secondNumber)); + System.out.println(divisionFormulaRead); + break; + case "*": + CoreFeatures multiplyFormula = new CoreFeatures(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + String multiplyFormulaRead = String.valueOf(multiplyFormula.mult(firstNumber, secondNumber)); + System.out.println(multiplyFormulaRead); + break; + case "**": + ScientificFeatures squareFormula = new ScientificFeatures(); + String squareFormulaPrint = String.valueOf(squareFormula.square(firstNumber)); + System.out.println(squareFormulaPrint); + case "***": + ScientificFeatures cubeFormula = new ScientificFeatures(); + String cubeFormulaPrint = String.valueOf(cubeFormula.cube(firstNumber)); + System.out.println(cubeFormulaPrint); + break; + case "***/": + ScientificFeatures cubeRtFormula = new ScientificFeatures(); + String cubeRtFormulaPrint = String.valueOf(cubeRtFormula.cubeRoot(firstNumber)); + System.out.println(cubeRtFormulaPrint); + case "+/-": + String switchSignFormulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); + System.out.println(switchSignFormulaRead); + break; + case "**/": + ScientificFeatures squareRootFormula = new ScientificFeatures(); + String squareRootFormulaPrint = String.valueOf(squareRootFormula.squareRoot(firstNumber)); + System.out.println(squareRootFormulaPrint); + break; + case "inverse": + ScientificFeatures inverseFormula = new ScientificFeatures(); + String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); + System.out.println(inverseFormulaRead); + break; + case "sine": + ScientificFeatures sineFormula = new ScientificFeatures(); + String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); + System.out.println(sineFormulaRead); + break; + case "cos": + ScientificFeatures cosineFormula = new ScientificFeatures(); + String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); + System.out.println(cosineFormulaRead); + break; + case "tan": + ScientificFeatures tanFormula = new ScientificFeatures(); + String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); + System.out.println(tanFormulaRead); + break; + case "invsine": + ScientificFeatures arcSine = new ScientificFeatures(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); + System.out.println(arcSineRead); + break; + case "invcosine": + ScientificFeatures arcCosine = new ScientificFeatures(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); + System.out.println(arcCosineRead); + break; + case "invtangent": + ScientificFeatures arcTan = new ScientificFeatures(); + System.out.print("Enter second number "); + secondNumber = Calculator.nextDouble(); + String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); + System.out.println(arcTanFormula); + break; + case "fac": + ScientificFeatures factorialFormula = new ScientificFeatures(); + String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); + System.out.println(factorialFormulaRead); + break; + default: + System.out.println("Incorrect operator"); + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + } else { + System.out.println("Please enter the correct letter"); + } break; - case "sine": - ScientificFeatures sineFormula = new ScientificFeatures(); - String sineFormulaRead = String.valueOf(sineFormula.sine(firstNumber)); - System.out.println(sineFormulaRead); - break; - case "cos": - ScientificFeatures cosineFormula = new ScientificFeatures(); - String cosineFormulaRead = String.valueOf(cosineFormula.cos(firstNumber)); - System.out.println(cosineFormulaRead); - break; - case "tan": - ScientificFeatures tanFormula = new ScientificFeatures(); - String tanFormulaRead = String.valueOf(tanFormula.tan(firstNumber)); - System.out.println(tanFormulaRead); - break; - case "invsine": - ScientificFeatures arcSine = new ScientificFeatures(); - String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); - System.out.println(arcSineRead); - break; - case "invcosine": - ScientificFeatures arcCosine = new ScientificFeatures(); - String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); - System.out.println(arcCosineRead); - break; - case "invtangent": - ScientificFeatures arcTan = new ScientificFeatures(); - String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); - System.out.println(arcTanFormula); - break; - case "fac": - ScientificFeatures factorialFormula = new ScientificFeatures(); - String factorialFormulaRead = String.valueOf(factorialFormula.factorial(firstNumber)); - System.out.println(factorialFormulaRead); - break; - default: - System.out.println("Incorrect operator"); - do { - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - wrongOperator = false; - } else { - System.out.println("Please enter the correct letter"); - } - break; - } while (!wrongOperator); - } - System.out.println("Do you want to exit? \n Please enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - reRun.calcRun(); - } else if (inputEscRead.equalsIgnoreCase("N")) { - System.out.println("\033[H\033[2J"); - System.out.flush(); - } else { - System.out.println("Please enter the correct letter"); - } } + // Exit Code + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + reRun.calcRun(); + } else { + System.out.println("Please enter the correct letter"); + } } } +} -// -// public static void print(String output, Object... args) { -// System.out.printf(output, args); -// } -// -// -// public static void println(String output, Object... args) { -// print(output + "\n", args); -// } -// -// public static String getStringInput(String prompt) { -// Scanner scanner = new Scanner(System.in); -// println(prompt); -// String userInput = scanner.nextLine(); -// return userInput; -// } -// -// public static Integer getIntegerInput(String prompt) { -// return null; -// } -// -// public static Double getDoubleInput(String prompt) { -// return null; -// } -//} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 26335b1..125bfbb 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -23,7 +23,6 @@ public double switchSign(double num1) { public double inverse(double num1) { result = 1 / num1; if (num1 == 0) { - // Should be error System.out.println("Err"); } else { return result; @@ -101,6 +100,14 @@ public double inverseLn(double num1) { return result; } + public double cubeRoot(double num1){ + result = Math.cbrt(num1); + return result; + } + public double cube(double number1) { + result = number1 * number1 * number1; + return result; + } } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index 5492299ff5aae4e7a13e996b9a8ea50eb150c4b2..b0d67eb0c01ca2422623fd5f289acd17764f9e8b 100644 GIT binary patch literal 5851 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 literal 5984 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 R;EMwPWl7L9x%dS%<3A*7AL;-A diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CoreFeatures.class index dce1bc9695456ca0582142741a2c4939db240747..0e23e64700c39bb3c6944a378db74770fdbb39ce 100644 GIT binary patch literal 729 zcmbV|%TB^T6o&tyEd@lmc)^W{t^^l0x-mw>LI^9O3l00}bi~27V@ivOFJ)YrxbOjd zDB~F-*yqKpVRyPhH8KC3WN@i5h~Hx^39sk&D}@K9tSPj%vTbRv6_r&%J$40eYk z43)l$<#iVMGP&b^NR@hDlW4#bW%60kP9GGB&intIcR_FFLBQZNyWLio!HuUgPZ-!= zcFIr~XMUP+^IJR0LULB1CJd!poh3r{lzC!p{wv33PdI=}>odmzO+lV)kur}wGu5Ma zur~^FD3LYSfQ>b><=+PK>y$BUphDJ&uc*T@eTOaaN`78joND)Bnfsa6L{-#g>^emj k#hc4`!$n?oW!}~@-s2*#u`+La8BZ_r_EzTYOgGi|0WLalbN~PV literal 1057 zcmbVL%Wl&^6g^WXackTreex<$C{VjVE!ZGb=z>O-kRm_|%6>AQhADnTlW`IJ6oN%T zEcgIE3USAcnl@w+;l<3o<8#hEcdq^W&(B`~_7HiPf#ag$qly|sqPXi-ULgfXKR$HZz%A>bhWu|Sk;)fn zG#KU+mC3g3bInbz8CHVulv5Tbg35YCSi-W46(6fuyI8ISkUK5=lG}>GtBC?vaMi^% zAJ?(Yusp#PgWImls8xXJKT$K2aFzEo%66k#?ni$GZugEVXhXb+}eGA0AfBdqt#Yt^cgI%P>1A zx<+$5ylT*FhD~ZQD+@nnV595_O^e4dIZTU$z)q}=i6RooX&_!ZFSL*c%357K-_nk~ zMcl>>`gZJ71F_2W7G)7-jP~mGcd)M%%wU673j!)c1N>6}?qHKLhP${&t0liAMAhQ9 z!rm9!&vU(!y8*|(A98JUA6rB1fFg(DaFU)F*K16zw>?Sk!?@ns)Orsl>E+{k>r?AJ rJiGiCW&c3^8{8k5Z^S29Ji+DB80`NJ8pr~Pk48~H8^xpY(s%v>bD6w+ diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/ScientificFeatures.class index 2850d392d1891c9a08769d6d5977c68afabb960a..ec3ab741ffc05ea78e3a946447e7b36ad78094e8 100644 GIT binary patch delta 289 zcmZ1~(k04u>ff$?3=9l*3>h1_RxtCkB$pZ1R(Tuo|&y0(n|MULdO;kfje6U&3a{YQn(9U^@90 zTNJAmkYzpDl0Aym0myO$iYZRs$(|+a#=y$p4%FkpAjaScG~bIsmBE|A6i8b$_)T`; z$Y2d(;9v-zypctI@)-^z)(D{5NU-@zocgSBK)HCZTq&m!YcfzS1uSgxvrY5s}^O% zWyK9CCo1peSG7Pk43zkzI#dx=<*v`6hNz}wNq+jai53WL>2wf57jg8ELLav53I;sX t)--~KF$WBj-i#i diff --git a/src/out/test/test/com/zipcodewilmington/scientific_calculator/TestMainApplication.class b/src/out/test/test/com/zipcodewilmington/scientific_calculator/TestMainApplication.class index 02d8c0455707c804be2cd2d4893c7437c82186df..9add06d051cb5f4d5c45e68bcdca9a1f6d745eec 100644 GIT binary patch delta 99 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 PoG&woM3-S#(EI-aXZhCF diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 8dd17a1..d78234d 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -9,12 +9,5 @@ */ public class TestMainApplication { - @Test - void TestMain() { - ScientificFeatures inverseTest = new ScientificFeatures(); - double inverseT = inverseTest.inverse(0); - Assertions.assertEquals("Err",inverseT); - - } } diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java index 76c67c3..4132337 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java @@ -123,15 +123,16 @@ void TestInverseLn() { @Test void TestCubeRoot() { - + ScientificFeatures cubeRootTest = new ScientificFeatures(); + double cubeRootT = cubeRootTest.cubeRoot(125); + Assertions.assertEquals(5.0, cubeRootT); } @Test void TestCube(){ - + ScientificFeatures cubeTest = new ScientificFeatures(); + double cubeT = cubeTest.cube(5); + Assertions.assertEquals(125.0, cubeT); } - - - } \ No newline at end of file From b9b1e00a3f284631075c9de36592af4f8bcba394 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 21:34:32 -0400 Subject: [PATCH 35/46] Updated exit code --- .../java/com/zipcodewilmington/scientificcalculator/Console.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index f642927..585b0cd 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -165,6 +165,7 @@ public void calcRun() { if (inputEscRead.equalsIgnoreCase("Y")) { onButton = false; } else if (inputEscRead.equalsIgnoreCase("N")) { + reRun.calcRun(); } else { System.out.println("Please enter the correct letter"); } From 94689fa19b92588a4afdd9132c68952899f0ddca Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 21:54:46 -0400 Subject: [PATCH 36/46] Fixed switch break's --- .../scientificcalculator/Console.java | 3 +++ .../scientificcalculator/Console.class | Bin 5851 -> 5860 bytes 2 files changed, 3 insertions(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 585b0cd..ab4087d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -94,6 +94,7 @@ public void calcRun() { ScientificFeatures squareFormula = new ScientificFeatures(); String squareFormulaPrint = String.valueOf(squareFormula.square(firstNumber)); System.out.println(squareFormulaPrint); + break; case "***": ScientificFeatures cubeFormula = new ScientificFeatures(); String cubeFormulaPrint = String.valueOf(cubeFormula.cube(firstNumber)); @@ -103,6 +104,7 @@ public void calcRun() { ScientificFeatures cubeRtFormula = new ScientificFeatures(); String cubeRtFormulaPrint = String.valueOf(cubeRtFormula.cubeRoot(firstNumber)); System.out.println(cubeRtFormulaPrint); + break; case "+/-": String switchSignFormulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); System.out.println(switchSignFormulaRead); @@ -160,6 +162,7 @@ public void calcRun() { break; default: System.out.println("Incorrect operator"); + // Exit code System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); String inputEscRead = inputEsc.next(); if (inputEscRead.equalsIgnoreCase("Y")) { diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index b0d67eb0c01ca2422623fd5f289acd17764f9e8b..384322c00149eb6d0e81ad2f7c58a277f2328425 100644 GIT binary patch delta 752 zcmXAnYfR2z7{-79|MT1oZM`pv=8znQ>SZFs*hD0iLux2V{#6mXqqW<+qTQ)Y53vrL6$w0RLc(fMpbJfod@ljMnTj+i{lwWio|h6z|&jb&%^ z!xQVgG*RAIr_wC3TwzMR5zbW8=pEwe6E?K#tp*y)=@KRl#F;klG=E$Gmn>G1#{^0! z=cL_=yWq641qiX948=nadfFLC7(RM2ioT2|oOt??Oay5RAcH~HDbjikvu;u36U}C; z-p+9L5%_?&9kgq$jR`+0?4rjgY&juaEMm?5I zI*!dco-I0stvZu!I-Bi!IXiVee!YWTx`5rfkUhGDy}F75UBf<42FOEnTjCA9ugmO&6DV4#L$#BXgj^mQZ2}!0x(y5eesw9_F zvW7FViLV|L^zMT5Zm8NtrD*ggRn5%x!Zxx+qLyltvD@B)QCGl!F!Jo*zp@ z3}wxx6n56wj94?XY34;UhPjhoH1opvvuFG4+4uRpcwT(pdAdAJGa|x{B8&$4VlpC< ztx!uaqS>}O%(%W@%b3*;^UOJi@usuybnCqt;F@4vHyN&2>xe0GSZIzpOgGIA9mk=V zUYFN;Y7*RDtH$Iz447(ntmQKy_sH<5=u!Rd+#*y%AJgMbvr^3DeuIN=*Z~Z5UKxao zC}*M>#$Y@QVLUNRWhj1P$s~?!=aRz+R*=9tk|-jPV#nOh7)lsR8Oc;Kkt!xp!!&A{ z%z36zkI!ymrX9j>-(!~DL5kf)s{NLuuN64T-A}U8VIN+R;s(KQV%Im9jsB$ zSgT&MPJLv(>ZM5iW`l;{Mjgf`J&4UZhAlddtvZ2idJ@~Uj~&|2PCbWRI+qe1pi~zS z)Wz)4rR>$^?9&yL=_<-~9s6|y2XrHqx`l(fjYIlAhxK!g=$9PTuQ{$iQKfr0p?_f{ zoRiX@QxaJ~wZw2*;;E4&&WMk*l1{B;a$XivCjl-mt-54Wj9x(oO(G%gH&@> zF4HL2Xp&Z%rHvcXPK!LDRbFsYUU6GK5R%WdwM-eX)=G`%D~}oFh>8EVK2%CR-<-_) qS3@4q?sUN=U3{k-n<(kz2c0N}$s>B4OyiNe=F7lVE5cle^#28x{j{+F From 3bfb4183a864ef5a46baa756fc6d98f1716de966 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 22:05:57 -0400 Subject: [PATCH 37/46] Added Cube, CubeRoot and Everything is complete --- .../scientificcalculator/Console.java | 90 ++++++++++++------ .../scientificcalculator/MainApplication.java | 3 +- .../ScientificFeatures.java | 5 +- .../scientificcalculator/Console.class | Bin 5860 -> 6591 bytes .../ScientificFeaturesTest.class | Bin 4000 -> 4339 bytes .../ScientificFeaturesTest.java | 41 +++++--- 6 files changed, 92 insertions(+), 47 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index ab4087d..bc5ef88 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -44,49 +44,63 @@ public void calcRun() { System.out.println("Not a number"); reRun.calcRun(); } - System.out.println("Enter math operator to use for this calculation"); + System.out.println("Enter math operator to use for this calculation"); // try catch method for operator - operator = Calculator.next(); - - - //try catch method for second number - System.out.print("Enter second number "); - try { - secondNumber = Calculator.nextDouble(); - } catch (InputMismatchException a) { - System.out.println("Not a number"); - - } + operator = Calculator.next(); // switch statement for the operator switch (operator) { case "+": CoreFeatures additionFormula = new CoreFeatures(); + //try catch method for second number System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } String additionFormulaRead = String.valueOf(additionFormula.add(firstNumber, secondNumber)); System.out.println(additionFormulaRead); break; case "-": CoreFeatures subtractionFormula = new CoreFeatures(); + //try catch method for second number System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } String subtractionFormulaRead = String.valueOf(subtractionFormula.subtract(firstNumber, secondNumber)); System.out.println(subtractionFormulaRead); break; case "/": CoreFeatures divisionFormula = new CoreFeatures(); + //try catch method for second number System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } String divisionFormulaRead = String.valueOf(divisionFormula.div(firstNumber, secondNumber)); System.out.println(divisionFormulaRead); break; case "*": CoreFeatures multiplyFormula = new CoreFeatures(); + //try catch method for second number System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } String multiplyFormulaRead = String.valueOf(multiplyFormula.mult(firstNumber, secondNumber)); System.out.println(multiplyFormulaRead); break; @@ -136,22 +150,40 @@ public void calcRun() { break; case "invsine": ScientificFeatures arcSine = new ScientificFeatures(); + //try catch method for second number System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } String arcSineRead = String.valueOf(arcSine.inverseSine(firstNumber, secondNumber)); System.out.println(arcSineRead); break; case "invcosine": ScientificFeatures arcCosine = new ScientificFeatures(); + //try catch method for second number System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } String arcCosineRead = String.valueOf(arcCosine.inverseCosine(firstNumber, secondNumber)); System.out.println(arcCosineRead); break; case "invtangent": ScientificFeatures arcTan = new ScientificFeatures(); + //try catch method for second number System.out.print("Enter second number "); - secondNumber = Calculator.nextDouble(); + try { + secondNumber = Calculator.nextDouble(); + } catch (InputMismatchException a) { + System.out.println("Not a number"); + + } String arcTanFormula = String.valueOf(arcTan.inverseTangent(firstNumber, secondNumber)); System.out.println(arcTanFormula); break; @@ -163,16 +195,16 @@ public void calcRun() { default: System.out.println("Incorrect operator"); // Exit code - System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); - String inputEscRead = inputEsc.next(); - if (inputEscRead.equalsIgnoreCase("Y")) { - onButton = false; - } else if (inputEscRead.equalsIgnoreCase("N")) { - reRun.calcRun(); - } else { - System.out.println("Please enter the correct letter"); - } - break; + System.out.println("Do you want to exit? \nPlease enter Y or press N to clear the display"); + String inputEscRead = inputEsc.next(); + if (inputEscRead.equalsIgnoreCase("Y")) { + onButton = false; + } else if (inputEscRead.equalsIgnoreCase("N")) { + reRun.calcRun(); + } else { + System.out.println("Please enter the correct letter"); + } + break; } // Exit Code diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 88b03d6..3472a87 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,7 +1,6 @@ package com.zipcodewilmington.scientificcalculator; - /** * Created by leon on 2/9/18. */ @@ -16,6 +15,6 @@ public static void main(String[] args) { } - } +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 125bfbb..2ef5e91 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -100,10 +100,11 @@ public double inverseLn(double num1) { return result; } - public double cubeRoot(double num1){ - result = Math.cbrt(num1); + public double cubeRoot(double num1) { + result = Math.cbrt(num1); return result; } + public double cube(double number1) { result = number1 * number1 * number1; return result; diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index 384322c00149eb6d0e81ad2f7c58a277f2328425..564bce1e00bfed178d45d1691e5c32f203a6f63c 100644 GIT binary patch delta 3179 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 Date: Sun, 26 Jun 2022 22:28:25 -0400 Subject: [PATCH 38/46] new pdf --- Scientific Calculator.pdf | Bin 0 -> 41552 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Scientific Calculator.pdf diff --git a/Scientific Calculator.pdf b/Scientific Calculator.pdf new file mode 100644 index 0000000000000000000000000000000000000000..3c8462febd78941230a8e595a9b21569f06a6db4 GIT binary patch literal 41552 zcmbS!2RzmP_kTkfArzT)m6>_3d1Ym9*$HKf>^+ifDzYM5B{Rw zdiF*T1~EPuI}FCo4dY>l!eCH#CU$mu;6GrTyp`eMLj(nJj4TZiHgN3OVxR|s;;@Ox zL)a9oY%TQ6_Xct94HCVM7=#)sCkkQ5VUv?V{$B$jmzRTZ;;^Y)huGUX7#*yO>mPJM z0riI};5f&1YYtit zN#MHoYJ4vdo{FZ1U#Mc&eLJ6Y_IQk==L6x+WQMsD^4pgf;1^n@hM)CBx=NGGw#ZL* zgz(3W;hz@S>}A@zFT|;nDZjl~@+U8xjNS9}S>bYOTyMLc)jJ;Z4}NEFduu$W#<-Uc zRcgwwziiKzm^i$WzPKXmw1U6E<{{pAi>ceK^YRb7YcD$+Ft_5WbTPjX>pZ-Emb6TL ziCdoICHaZm;SaZFiQYRVy`;(dQ>ExOh?&Ozj6a;*h9yD!4@dir=#Hzu+T-z93lp4| zYBqitop-ALF;l;_u`%;^%-=1cq@<)&$X?@V;kRD+gRi}TBwYfb;XJw&X1;$HOG?#o zB9sF*1sKH3%KZj0rXN2wrL?#u%KDZgcQr+5YgnL6$o_0S8HRv}H5=q^yC^G@##!dO zr-i>PMh$M<7PmhiR*h9#AQR>I{f$LGoS-&th^kMoPL=Ir3JJHl3pAE{;{-*!y5bx2 zH|^??JtR!Ar zseQZ*Iexvrd()+^_zh`Ia&8vZVQ0QGJzv(1U2v=Cz84m|Z2cqSdko)w zaW5#zk&WWwB)#dLtHB+3lN579RLmiE`h$^ENptp`d%`0YW#vc=v-ha8iEYcJZQ&X#@v)UZ~yDDHCZTWyL$5N1s8gY>d17x6c#51?PBpN!RPv z+X3oQ(bl$c3~K?lVNHuC`4Z#0@B`EvVj9}p*97Tj@4pG4uB3lSOhoU$T&qU2Ana}I zo7R7gB;QI%|1X6G;Wu{{iuHobhQRI#HJY}%Oet&L+v0}jtEQApEv^dqEISb@S{`#0 z^Qhb%rF@FG)9tOuR&eIG6~- z0+(dV_1^g^5t2YDd%d>mkiI#-wvJEu0VFUfF$`Zgquu8KzdsO*G=`6VQlnqEKJF&T zl@sH>%`2nBAyXL5vN_$7YnOAmp6N7?wY6CY-*I6x0UKF6(nfdrjVj8tj#@&?6wB{I zj-5nwA$RGBGm{@Fs&5aA$E6U!|Q-6$g zZ=J{udCr;k;XQ$R^SVi5bc8o^q-{uk;X9U3B2)F_4?jA06j@D~lyTl&yzte|ex>I| z6MXR1sJ^W9B4ypl+j{AF?Q$|pcePm?W$%T*o^z2UJg(IQ*JUwIxWJat_>^Rk{pZ8w z4I!=oN=B)2R{J(V4tRwW3!F+dxu6kZIhN$b3BfR?>72!U=IZbFA%~c7JFvAq7J_>Z zK6iP(4xdIaf*Ts0imia}Lj3Iv$)Np5qi4DwRA_GoJ`#C1nnYxN`x%zw9A|Twu%3JE zlN)^c-KntS*>c6XGE3N8@$Z?jhc;v_SG_#XLJO_7n@axF>8^}NS2AmJz3Ezj)%e{t ztsmvh@%>1QpV3nyJLdHi|5!$k`{3+^MMcteK>|~*tw}!hPza%@TghXCil&lZCYm?X z7;+x13lfp7&zGn1ej0&0#jhjQshzsLvtq&aYQCzAwGo8vhMoyf>XnV`tQ>3&jO-x5 zvI;Dr1}aAO5G~~D$);-LY!6|Rwg3i-?0kyud`j!!u!%d{ORCr-)>PoDk{l4kny8G! zCdmmwEPRN+aX}EvmNKv+vPoE3+9SqEa6`CJKb7Et@SuK*__@51p{bsTl`}+(9T4)s zp{(p2a5yi78wvw1B?^4o$kN^pf>^l#%__h`X<&at&lV{JmOIp6A#jw!-BlX#&mG3F z=d&F`odaMEu<**78rng$5YQ;=?5*2Sgk5OgLtRhY+{gmBHe#W-L`i@PL!dkU$U?LL z|4`SF7X^&GVFE#F2AmU>7K5-03Id)0e_^l$7Fl-WA1DVS=&}e!hh0|8)Dd|>B&dM# z5G|yo%KO#Az-mF%0cG8x-t5E;R}>Xc5|% z_yjQ%>fjuK@q(fHx5^8G3hCH>sK7;o9}b0z>j0=Yz!5?!IxPG< zP;nqiDJlVxmhP`r9N@B!9DbNuG;cr&h;nQnR2<-@#ptM9*~My)pCC;=04s1|=lrMI z3&slR*?z3RWrOReTtJ&wTzeUDI93M{c5bv79Ys@iu;SVyC`eQHW5o@w?8xE&KRJl< zY(G}uy1{i+E}&zzml20!br56cMvKu=$+C;p9z#KzdH`17($4iy)fY6cxR9Rh!-^YR zH@J?<1$3};sMtU?xS)6 zO*!{oMjVdSL8P4rEk;Kr%Pv-XBn4^e0a$@+JNG}8Uocik&-P;lt{dD(amC^Xz5B;aD9++j+q; zLTWlJS$477V<|{e55Njs+qwU#{DQDTdA1KLUU1#uIVu;><`vIgMjVdSLA;$8Ek;Kr z%MMmNdn^TM>H%1RYddoIVIe?s2aFZcv;A0s>juwJxqzmeXD=fT#R_&1Z-=AB=%{4b z#cGeGAWhwm6&zgKdH$*Vg0Vt+wht>fxNh+N6L06)%ZS6VI*7N!(PDH|vg~5D$5N1{ z9)K0Nw)6Z``2}Nz^lU#?;JU$kR4$;+E8e|~I2@}3csrCGEk;Lil^v{j_gD(j)O}b% z*}=6PIsE@82T`8w#|m6Gc#p~jbgcF=;&7}E;O$U$v=|+gEW23ku@t1K2Ve!R?Y#d~ zenIn!7wOr5V+Cag*A3pIaseHyy^J^?Ri1!?Mjtk4co;r~>A!B`;{nw|Lt^t1lwnkaJ*Knz^vQC~PL6zD$fRhJ$2_Cp4) zAyD>zTSeIS^5f7s#&H0PhoYUTLXoNtbL>Bm?Xeb=x%(kQJ6Hvn%0J}|7&4@L`yfL* zT7^RYiOU0A;6D*R9I^w*Jd^`HSVyJLe<0flfDByoq3r)um(dav>E3?Gz*Qeu z9ae_z|-L1UNa~sxcWnpU-;jB0wpHOy?v0O9l1h}Y$`*K z2y`z=4u|X@hR=x}tfSKBKalM)8kD&Q%rdm{|BtPVV91c}?S~Alq9B{O{`ZK0ddv=o z>>#4gg;sHpst&vIE@Y^_Kjf)C@VEz}mhSV33vK@XV@o3lGL(D!)uT;fWVhO3hNI6i zP_NnHkR8PL(GCEiNL7bj`9F~D5gUNm9Sj-T{QbAqMsVJv+}jTs+9ZY@l^*{E*LVWe93>6N21`1OA25 zg4%6?Aa@3oA;_Cv-~**)=Z*$~V%^HXCvx3^p!gB+Z&bAaK2f@$sCo{8qMDR}Ph{o+ zpF8^gkM>5iEwv;0#PI)Ro`AR_GN}92qOEmD-N%br88}z~ zPeK3>?&(>YKp2cHS=3YzPecM}BC7Y!;&)IXXGh!O1a7f*JlJ`%0J4Mj4%j} zQiY&8Fd?Y!LI|pJ4ua|mgPPQ%ZI_-p@4)P$V zGb#w`_yvMGS%9E6%^|4$U>fzO>egn|W_Q%LlI z&z(7hWPre&L-7RQb0^PG6&-@As=&{8`*U|5t$`vNV9^4PdLBj9)(CjSM!~@Xc*uku z_!=tMpeH`SeYSF@7N)=xE?S_+LxA9bo)&=uRSB3W3VIg6(>nh>40Znj8qLnm%?Nma z2s)aS7m%Xd244scNKqhxq`)>M1jU@e8i1YAoo8Oqq=2bADGJuW1xQf|4VEG-L!~QN z%EP!j-M~`7vYi44k^;MEkewibrGULVGZicaEZeD#U@0dcMTHkE1?=6Kztzz)D}MFx!pwjCg-as@^b*ye!jq!xHAVA)PF2TK7YQQg;Q8UTBD zvJyNNuxw`?07-$HQV7RB-+-Io-Gl~@MOe1aH{c!(f@*06+W_1X?$!dZ2EekN)dwsE zkVLhxqG04xQNM0FRTX#niqsqx^k zfMq+Z0we``TOi!~d;=P3c9#e6ScGN!<|HqGB&uHnYy;31El}$ z8{&v_ckKpgK&&`BY!NI4kVKuNfo%W|{&tsr@L0gI9ij=A0!X4x&d@Xf_UQa$~R<0CQ(& z9!&{g^DfH)jYcdxyTlqS2Jl4fpM$9ZVt*YF?~5M?(!hNIgd`V)a4ov7%XmSblcN8OUy6yABZlH%&oo5(47?Udw@(S0KbFW(QV+G;p7n zoCsj|Q57h#PX~zi#gYqg$sKMC(hY1R0b&&C1d9<+?V~GDF2p7G@f9c+;*$Fa3ly=u z>=IItZs4{b5byI6*lYmA`@95pHvsXzSR$5<-5V&dZiFQ}Hz^WWd+>W$O2J7P+8!n2Kmr8;wK8g)GCuwluavJhqN{ z#C2DK`k9d-@_j9U=AGx!cg+Rz0%0rok_gCmE{S@%3KST`!OIIg7=OqMSh(T5z=q4- z3s}ls+_leZM1B`2%6Ok{nN;e@TC1M%BI)1>c zx67muT7p)75gN{%$#7dJ`Icb!~Ku7>G{%As8sIcW?^% z`@Q2(@39&!_%oZzlCMk7OULK=;Q4uim{Z6_PT?=nZFE%*l2h z9h;JED`OXv8ZY&siJ#W#`C>P}tU+?6oHdSZT3mQDMDKDilXYB2sjF^{m%Ic8^^mI1 z3je2~e7E{p#ceDXY9U)ghc&;XpCT=a?>x?3`WEw}yBSuO@f2&!BVhdw#-9yLtdJ2s z52Dz!g2l`?AHW^CsG;9NzE(n>T!H!!o%76r&gGRC)!gqCxp?J7bylq?U&w$&%~R{h z@mF^Y^dy$GShcO4I0XyE-u z;Lk69c-edp2UJVnj37$-LJ9Ad-3Ez_xX%R)wlHh4TR%i|J+X*jjWDky3xzP@%20eO!`Rfm+^PR`(0q~1<+WC(q<>E|F{SE8d-0th}_(k+U zx~!wni1On$NB@@2x}QdcyTVQ3CL5h4k4T{r#j7tZCY)vOP&cjfvs@{y9F`Ou{Ap^) zLSYwfGo(0Ut%Flt2x$md3>a?Ai?e+c7r5$~9CjmL5o-K^Xx`3{uS96zn>2Sc+58zp zA{+5Pr{@S^m;#R28}r`ZD^K<epeH4nMS64-^{$0hEDM#nmi?Vw@8-o1^S5!N)x7RXSQA)!N5=M@nvyt`-uT?&z8=jd;&+4yt2J;pD3n!2TWPOfB@ zs$xNC_LaxqN0UZUo^rPF+7&9eU^f1+`@Q8p?7v z&-+rtSF9djUZfTB)tbBnIn_RH&}Z=Os_jKSr34Lv!r(ct*q`jlq29XPCTBt&`G1ax zWDx{o9O{Msc(>iSo=g|Au{_EqBZNv-89iK~vRkQ-pDp<|jTCLY2)p<9 zFIMu!><|HtmXJpgS?iADuf}SE;=NQ^t{H`Gd)OMl2IemP#`!&QM=?xjqd@k@hIPAt zs^H|!bJcBiXMIC+RIKhlhxI?54?Qby^Pm|^D&~|z#e7)7IXK7WK;SRtZLDO|rVg3t zCshs5@F%R-gW*q2>)!{TdW!v~-)?RwC$rv%(Avz#Az;n8H}=%r&JSj-oA7mxmsFH845qw8*60Yj-y^4C+7As$LF)Xo+y~ zH1525TcONc+4()}srN~`@l~a`K*YTvMV>kRhXq^`^tl6^p!cxjxY z_|od{ys4Azms}GBzp+KKxJ{M+iWXq~J)Nq(^dsK*H|8~+T%)M6$EO`v<_B``nO}H2 zFC(|A<>*!T*?du}uz7HLE%9B0Cw4yYMYJmq;P;?B&$Pg5v47n`sy!s&1Kh%vtK)oid*JC&*v?titqUM;;T@U?UR+ycwyOf3H83%dG zw`W&$B@N=Q&)uXyD{E-%wk^C}^?vKP)1;Tw(z;+^cqtIR)Se6L9U9(S8?j&~ELuOs+_Ng5ox^0FlW-_Y>a8Tc>7s@kOA z1B17;V!rWkaks=?OMS5V=KZb8w<)e)akI=^jl_TF=cd1=t@AyVuvx~~ubJI~ODiCs z5Mr2jYkZ=G4*Kyffipe}tS)uEG>%$BBfyE#!NJA+js2CRKdizU4S|sDa$ahasNk<< z7gR)BrtZ{qU4A}bA@`1tNlJY9e5#_2pF%G~8{zl6W;I*cXGs34?wY>7=uEU-LD=s>Sd(67gLynsaN8E_NroTbbg3Z;} z@%|O}65a)8YjLLwF?WrEEGt4JvHij#qKoDmYnQUjEk8$zMfrwhh$i1NwO4DH$kdCA zuXvFi6M*$3va`!E&bgiy{{o!K$~h<7@~vKjGS|klW}dE|JboG{xGQ^SEdz7mk+`riq@T6mmBGAV6X_rBC{{KA!qy~ zFNm+$Q7r#*)pUI@Ebqh!wSh6Npt@=?zEL(`UUmOzd{}UhzK?BOg%Ot$KX-+HTGdec zd&{^OPrOhChxjX50xY&u@-KMjpTIs6L*>#PCRDWPj8FI|(Y*40&Pvao=v2tq9O3x7 zm#mX~uy6Ret38Y4vlp}cW|@(05>AX~y2U!JUGG;#kS&!`IWh65Wex>QLJgE#JnA>&ilE z&rl{})E--wrqnd&q#?tzDN~Y-n0fNi@Cp~j>pL=);ok+ZE7&}hWFm8u|0Mg^mI;&5!ehGKYF7UCg5Y2T*L%hE{ap9xSF@z#VU9h>OZZ!KP%Knlz zO%&6Bi1Vp=8DirS&Hc&4xFj1zvyp%yN$V`Jp%rNPOgB1T;Ux=^s%!`~v2<7Vl{?|1 z9Dev#G7HkbjIa~BUDl*d5@kik(B7iCo`MmEq3X50oaNIi{Z9Kt@?5ECbX3wB$Mk!# zP?&xt^>H}EhtEW~Qd+d{#k?f2RZUaGIP3=o7D6`Eumzuu>P#C1UW_~@-hbtTf%&PH zs7R@N2`{3L$KJeWj!M2q^p~Z^zcLhG*8VNV?CS;DeE%1sp{iGuqA;X4=u)?sYA|cJ ztcWN(3W}e-c=bsDx0S5}1N$Mnnbbl`74R_hihSVu9h7Q;LJ#!t~tWSmx zoAnX)V(Pjbe?5ig=`iJSh=P|zVQYEo-|UqxMkW`NSaxbY24<;= zpMIQ#OC@id+ZtXkW?m{;`F&+fk-=9yV#t+`yWjXUdw-aLQ&rw4ieY;GjVP8Om)C_u z;_%-5TeM|3-o-|9vU){7DI2L}pN7xnybTVZgVDPi&M{?0tWZ9tQ#emTHgw9eLHnle zsmE%C%9$LxPP}tvDhvc^D&L9laW42~p14h;t3adn>bByyfva!p`5tA=QO@UY9jAWf zd&<%&g)cr5XE81;VeDm{I5sWWZLVi@XMSS^rmiNdHo;>qS+Xf>#SKD_y?1KJcQa zC((29=coQ}Q3^OCPZE17^x85mM7r_|usxWI{;bv~@NGKDYQ@99@1zH2%DLv0tfBHG z?zfuFOL!F>MPK`R`sdhc2C>I%*2HMkVjfTUkmh~X)=h!f^WvR4Z8m!H;;~QTXJ(I8 z=A4vJ5Pq6QF3+%Be662EqFZ5>Oe;F|-7$01RZfawN34#sRxZ_vKS{Rge#XfbSzm+&3aIb$?+`SWN}alAfkx0tZaZ_ayQ z_vzW1Klog8CgEDr7a`RSyL91EitmNM5hexECQ zp^aJDp7`w)=6J*`N38V^n1}ZTm+#Jr38_(xPCj1IJ)eE;g{GW7o%`jUpC75ETK}0w zrq%u_Rv9nElDH(Q?#eh<=(&}vU(ar<7Re0JbdnG@kxBST2^C+ht{Q}3Bxs^bx_G0ozF2fMP*kvuuw~yXw`1oG#3K%8$a(PPJdF=ER z2eHkYlh!Y#F!HdZbk0%q+xy+5v5mSx=PH9iNA-nTBqV2!aJpEvTxvWFYvJ)bN&W_P z;y|tj_e=(DgHOws1umb+rqH!zHGB!Bi>jlzEI?mfdU>vw7WNoFG;%ylejMMXGVNI+ z!N>()LBb*ZlACO{{G#cSC$80Mgr@1qVZ7JkXSz)Qzsy&60?M!?QH_a#|I6-@H zRNAVeko|puO{dzdNPkZDK}e$HBWb+;2l>`sq_STd<`g}mNo^%aoQ5zuFK|Cbe_d~5MmY{ePyzbzKfP#qYLL&T!8{ZycJA7BaHTGzW6}UskesrVhmd| z%x(yX={H)bcDFlFBs_Aad!Ms#v2Juzc*Xt}6fV9L_As1uX*Yg0rD{8Il2@8`H-d`T22Xw>jw_Yva znr&q*nBV$cG;31lFZ6icOl$DZpO2X1x-ZjL#}a9|1l?Vi3!f&$a1^-B#;t#SEp!S0 zEX!Iv1%y=R%^s|*wWOI{kucjS891rdpR}ps-F5;J^{;svX zA!PD5U1pcq8^(~ZmxDo?l59rLTW;2Ge)ub&PA?i`NvUHPOvb`;>HC}mec?u|QxNl| z`*ul_J#*N!XReyCDV%`neLN{N>n0Zm zymGAqX6bCJ_H=u(Ua21EK|(p}ePPPUiiujE?oWp5f8*kCy~C9Xj-R>7%s85Qx@q~; zdUuoK-2%Fvj@p!)E%A7aUZ>_roo|2j`tEwK{9@3_?P__MyJYFkf;Gp&YHt{a{qT$U`7NY+gwJjDbiHEf;+d`vstUoZW1IAh z7>wG&7FaQ#7(RK6NF`}ud?ykn8GUrj8;h4V?ws@F#|XQ#Jo#^VswLM)*~F#XDQ0r~ zt%POmFVVwpRS}DRCE6CB$`E)r&cvqB*T0wexmuo>ZdS^ELQTgTbhZny+aG7D-+`Ejqb zTkNIMBCdq^xdW^xw7k6&~cY;#Dv zbsq3dB`)H{_gAcF4F2s_OdxaJXqk96=CL{K*Q!OF^~%t7t;Ig({qL5%*5$PX_sOx( z?FIS#Zmtv8-uf#zF3ee%UUP)G6#6bqI4#T5ct?b^P0&ykT*EGChA%$Tbc@s$j!XZL z9>UZ3RVeBhwo-hqx~yR`H}8s5XqOP3+9wm1AhLvgC%RMLgSX0#UFw%KB)JdD=`Y1V)V5MR_<+b(DsGB zEo5db99qbWa%#IFR%7J7-ZU~oZbYm}nAx+@bd0=__&)0nnAru(rb|JtjSxw|Gb);$uBZml`1xz%^Qe)Fd8obuayC4=9dgt|j1E*r7b zH*;`bn!d9*A$eucZ!%d+r7_~=Gy0{8`JM7 zX>NDjx}@4Nct4T8yC{W`!^$k9agL#-g(V`KC35I}MNi4uqOY&Jv!i*S&9P>y>V^u@ z=0!KZtjyZXG8%ZiRK!-v$+qYy*qSj*TlHU8HfQefj5~16D?B~+g1uKsV7W)l* z@$TB8K=G5{o*8f?6vDHsxy*8>$0EjX^-h4lGoCx^ z)}Srb`rG8EuRq%hG`}IK>7BRd0IQ)}RtO`zUkjp)9Euw6&~VUjb|H?q~U2Y$7Lik_t% zi-?uEAu!5Z&%_S#`y8&@830Y0KtBT)D~yMO6ObU3Aw(=ND3lcroPKj7jt-41)PY73 zR-nC)mxl{@Ikld(l#!{)U3;M0g@+Y50fYgkgwntPrK!PnOA~V=#IKD&SSEseTQ&=n zmy?y97Y00x$il(S!3u-HfQB02bRWjb4)n~z5XX#wl$`_00rUn%hU>uZ-7o^0S`}>#jciR3ZLYgt1B5CL z*4Dtwxe?d`PY&X+X(0M7wK%u|S8n+NFQ0NPZwxS{N| zP8~!)m=-U96FWN(FH{H7nx)0f&CLpj!+^7Y&^Vwy6@ZkB3y2mMpc&C2q{XrKJ)qqO z=+}Yq@Bn%d5dj)_$Bqs74s2W(&m8WZ-^{71#!SREi*zzz$-o82x`@ar=V zJ2mED2fnp;Xsi?3YF5LJTfguChpJSx(P=;g>xsQDDjQp`~-wBXKBJvE%o+WH#i{&7&nb(%zBPH}>}ndb&l~3Jy5C^sg&SG(geTYr zd#iuHj$cz)zOcx3&!^8$?90#VqiI^fDQZrJ;@=gp>+0geUJz|>N-BTh+xiki%cr1Y zPnx1M%}6g3pdeO~N<+ivCL51aF?0Vj;aQ}1Yl5L3keEPv0FAvsSwM6T z0P$C~QnNHg{6-d_Hy7Fc0GUi1HS6mW5IB8tNy9R)yP-~k?Z*qa^kZg|e;ySsl1 zI2k)SON{!!y z)G-PocUv-svtu_#3Qu8m@DRKte$ThzCQV65xOT2=D%;^?W^ni4sVE;(E1KF0=ar`5 zw)O|kGs(D{ti6F(2lh=!Gb!TLz!87C`Bw#&v!Ss5vqz}~mwR2`~m+X_TJlcJCv;^d^s~siT*~pU+Ua=w`Oaxal4MH^m%<+f1e`y*$-JP z{u2y8yuUs0x4lYO$ljRt>eG$(?;$iVu@y-br5P}TeXgi;+k_A)OP5W$j!QDK(0!RC zvBff~ziXJDwJgO|I4n$}e-Bf${#NSNFSZ9v6?BOn3mJ54;|m2=fB!CY3l;mPi~@^k z^rD-8MGec;@c8oLTIA1nU$3`%-|FSr8veX8BS>IH;&G`^EHR~0a{JEQg#=0)?#^?+ z^HrJLFGn?aK-Y2EBm(I$|N5xP=gB;-bieuw8y4Wi%e1T*+P2N+f>G}>HaOs0H)%6= z!EnVsdi$KqX6(=PEeNH}rQY-5_TQ`;o3T3xwsnR>z7mxcy)?^R(^r>#(E4Jj z{O6fmJMs(7H8J!J_&y6*1y)8@O}akk4TR406fL%V*wi;WQF^ySLdn48V>_t}gX-xp zImRNWZSzyvQ7ps})+@z%M zntzfyjN)~e?AK9_#1`>&9P>&tjc`59M&`20z?cO#G{K62m2slGZ=lY~cEjs&6V9AKF3^L+QIaAK11R zg#agwSkG2N+$Vo{1Qz)X`P$=8tZQUD`rs#>77|woz4VeL*^5F_hr-PLY1u|=^61&0 zS4%F<+p`ENj@t=sc(?viu@%yhvP`L*C=9vQQH>w!{YhS;>&q%TGi@^gd0FJxtrcxi z`{z%>Bs=*0vLE`esCdv5-uX)a9|^QyeR=U$>-R<8`yXz{opSN;<4>(Fl;bgTA0pr2 ze|_$(?v!BH`#(~cWsmO<*R;~Ac^wZXu$5DNfO{)n`|$=pR+%l^6ZxtRY{)r+!cn4| zY#)R+H6sKFPrZ>JBdh^7{+s2DVLF&ZTF+UAZ=dW8$nV=7+cclniExVHXc z!gC_do>C&wyUGqCfXO%A|Hy=mzZvh8#7Ry9(lc>**4eL!C8uAco>cstliDsQucN5O zFMd`K+dwhS-HVkMX6y4l_!lMI&Tt0HL)RmwuJV%WYISt^yWV?+_nj2q7+JSBB%}*y z|8Q?|xBo8qor;Y7#j7jq+_sKBtbJb!OHFu+zFaec7vmKUa}DOcsI2aM%JIFVq{TL` zs4DE3P0-?xVu`HSdtIY(gE?7v3l!yfEV5enBT4Q{PLWZZioi~+=UTOf*bq~e-w;w$ ze750r`K@wd!j!v;=}*zDUb98&R`Rl^u48d)UQzfi)O77#caNnjwS|*2hDbnkbEJrs zV>uZX!zRN>qy#zx>=k0d@`2>T*fGlV|aKbt#rG%R^L1o!gw|Z}1l0r;(?@HYcn9=#fSK`9oHG z=^f_q-(ZMK@f`s#vBG{VNNzru8@c5FfmtadHkO=%gyqc|Te05OibHSrhFMv+ z+Oy@aSBa+*ay!GuU&4J)<=N@L^Wrq4$)-&UyUxpM=UP zS)NZ;k0t6Y|2EEfpLOy$700pp<4j&<8WR|A=C8)An8}@jYUp^UV?duZKZj^FOZ79S z77Q5Ul_?qJC3r<{&@qpw7~Ly8-Ih7^+bp{M1{2{;Y3UCaduEEe)q0NQYh|7sme2Ih z9Lx+EhPvN;on>p($4n0=NvVH%QPz`LYXRDD6|+D%FGDt1>E&bHn$yLBq|~-6=l&g=0Ok_Jike= zA<8F0Apd^zZ1tnt=NEpy>os1%FFNZK7eju_GOwv{%wTM+ro5X$Z``W-c52Fld?x7V zmoJndgBqgJcXMy6Zl`U$mOmczqagc-FxHk@pYkIj72MX(yjvdKayJMV@FPrRaAMc9 zRd6(epH#SOtxx+{T6swWDF#8TzMzWaAsl5na>*9 zz27be@(TNXxXV&VO(u~#p#J6J#$Y}lKK4x$_(?%Y>uHKllbP?5?0tIDHg0C0akI~# zAac-1Z@ysN?|QPM&?TxjJV)(Id7AV*(F{pIHmF*)oY5wJmrw8b@^w}&H*E?=gt7LhvDW7%i^M4n(!kirGaH^^ayDYXzX)sly-Iwlq`1GPCWH(|YV z&C!k3@N0j_t>a(xD`!>$H2!h)yE3K|PLd(5>g@EEq}xOwO< zsx?vTrNPc-snw_zkX4I7L(iKhWV7p?E(@-WuEy(1TWMAs;c6}T+}fiTpJmy>e#P<( zAx(pe#Y1*t^+&jY87mxag)Y}V1$4YrbGs;*!q5__!I4K**zJfvNW%3jz3=;VOU1IF zAR`)w8@=pSk>}$3%M7^tlsx1-sUF{oQD}b7zHs+0pMs})Vf#J7NIwht)U0BSv>Q!H zxD8j;)%7As^u<%h=@Znk$dt8Qh?9CW;!eD*w*SlyVN&RT$R+qG`7B<4{<6ByH}iZE zxzUrY(t&}-o^RJ$GyMl+ql3dqBe1rvA2Xj~pwjvcO^W#`{M=%y?BOu?(+^CfWtXvf z*^5cIPU`DME*I*R46Hsa)-+3!IZYq?{R-*diPKpv@2{QsLGpr;JcfaE{4$=Pr+{G) z^F2RK)mPgQ1Z2yngBt=*P!ki6nh9*X-cuT$)AoNw{5EaVmam?wG5Te==^GY*Cer+( zxgXBP{cUvquS~z?n(#Rm^_l+4ZhSht@MG(5eR!#(`~$DoYeF%7L2*7;=<%POOC-v< za>6m-9SwOTgg!N8>zn3B+zQ3C&A6ENX$>T;SW9ApR2|;8=|uEH5(A?*h3#p&2bxN} zHYsDK6~4-KE#l!emeP}oE_hUvZmh38dC{mN#~nY3ai>N|%qUty4*Vl@5FSbC%1pZ@grGra3m&mC-@OJBHZ8t2GHr}v6q%~?pO z?apM*{eaXmBI-ZRW5*QnABtUVD{b>`?ieV#O~ss1WikHq!I+8AAF`s=R-Vd@AF)=K z%j-iwNj@K|3pwBNXO(GowO)Ws^3uC%ZYF;AGu&+h+>eJNx#L!?$?3n#Z`cc@zJPLi z+bWWeB@y$s5&cLI5aT)MVqzq5u)+vEuTTr~elI|}ag zH!FEoL*t43$Nm0M*>>j}t?5xv8&7QtJJr&E>0jIs2t)zmI zTaJBUNPy>r#<6g*c#}+0ocTQDa{mpt|HQbZfP1NO`IK+anS}~dnPrx@Z8`51^-&*{Qkj#B&u9!9U}X@ke_1Zh~8y`5Be(w=xW;5*3g7w7d}2```@C*V%}H{9wl9+|e-_i$Q{%ga57ZG2&$4-%uFJx`U|?TN#A z?fz*3c)8apfsQfeAxq3s@718;hVFr$fo~E5v^RAX$d>ceB{Q#_($^3F;G=IZDq)O& ze)P%jut2FMr5}OYDR*osrxM3c=Go;%4OEzkFs>W77ruR7N40Jn;?jVh-#YTbLgIx( zwo0~E3_kWWB&DYMJp1d1+^5KiK15*28c++8sFUeB@P@p8bRMsxU$kfLg?UWbue*KG z>}Gf;8C!@XYQ_g?hI{D5(s8g`irb1_x``~DhvoE`7Kw3fs*w;IbitfBYrgx86vRK@ zoar#3tGu5w{c!?9=|bsaz_VrkWAt(C!uq0a-Oz_9ZYzPjl8CMGjz-0L^*hjXH8zC@ zTize?+%~W04fYm0k6h#JHBF?F)^C(B>LA29TU-6$w{*0h4R&1ogpaj~vn#KE!p%pQ zl*f;6zbs&R@w(G=fVm_4`>76#4(|@H^M8$hsdA)O>IP$kvFS)1QpZhu1Xkp#^>Q9N26@PJ#*|>n- zRF(rBCF<37?l>7It+-b!)XxYnK-nX|m-_X?u^``~HpSF}bM(F}cIpc{>Mq~jQ%nXf*d;PFUu8bG-LlGJ z5;?-Rg1xQSwSu!GIrX)C>V_Kr(`VJIB7J-m7hAlpFeWKV%h@E)DUQXqO19WX9d`tN zrSz!;36=K+7z1Zs3}VFM>RL4#|8aoey!?tE$igQcEOIt_M1(n4JjeQ$Yy>6oL@Ae< zWS6Ltw(0rFJl7xx&l22R0MUH=bW*NaU zSf0Yd!mT;FttqfEJlx1ex6L$bZ`kv}Rm#cloO$L>_bL zkG|oD@z%$YR+&X=Z%TWGoSIXzXQ|$0xh%*hsI(`yn?}bPv)+r*od2yH;Y-Ta*)HBkUvafl=YwljAInmuv&Lqolm~6~@?}E5}|6g(E8P-Jft$Q2N1r+I6s7g&B z6-4PGAV}{Z9TX9yhbB!r(z|q|2N6(u5dl%UNJpd-0Y#d0&&2;dDoM_L?!8}bKEa!{ zW->c#W^Z`j_1hNq3EMf_zT0K4w+3KABu+uOVNVs<#P}o&v;(i`CzI5^JqX(3^(XgZ z>m@Qtk#mrVlwL%sUE}UQ#w)xS^v;NOD#KOX%&tMpA4Wq|f(G^0Z`e*^;4IC& zKDDu&_4%8v@3eyM zYK%19PI&51*XdmmRX-{<`Z&J)ULYviVl0d{W%i>k7|ebx`AYsbvIpgxPUA)_k<{Eh z>Dvy5V=p65ZyH>Ts4u9~(|} zju*^#g&&{3bbR@a?-W&&(G+3mFgs-%z%q0HEQn6!{ z$QnOZc^vpqWE^VoqYLQ5~IY(OLuOv*vd#oUk!eq$L$`+QkG}+!YU_-w~!?Stz!DrN-es_ ztT4aKu4zs)LZe?Q?oJ0&aRZd9ky%v$Hw9eN$()Oym7R&Qd(1 zT>I8%9EOFq{ca%rRWQ=@#>^wZy(#nv6_v@(l`qD3J!MJF4HD2NIN+jSm z*Y})}9h>G4-%9VP&CSi=-z})W@A5fPai{;iIcKn{MebNeaeecTH)S0x-eNtQUmb%T zzLKvq%a^!l@lD?8?ex1`n)|BYS%(wv`%hujF9WJN4nl^--0#9zU-$$Nx!I3`Cbwqm zJ1Ssh$f&`!u4@x#+7bGBlu*z))4bi|jHgYEWkia>poLjz1gPyGSf*!xFxW-P3iQ{6?6mQ)RPl8?^x2V+Sea+K>Z)uwI{qBJ$*J&tMU_qICi;8YWG+Ylz~D*G zxuT%}EiX%*AJfE>Rh!Q*e*U}|(WUpYfaj%oc#YsW z_L<}p6+S0pyVyguD(YsK9o}c#Z#%T6V%VxA8%7^CpbauBDYFt^hZ2DpgFnv=b#P4d z1Spa@iEA87U9DifO&nT+>6FixQ0fQ`c3M~vZ>TxUJb9Uff43sQp6IJcOMME}f=W|v z`=&RUhL6(z&|Ge#ZAr~WPqD3!RZw;S|A!V9fm)IqRkU#!UWXuKOf?Z{ZxPya$n^Er zMSV2dvv=?9)F^jms6o+e#qi*;mBL!G*?WEAPoF|eOu|jTE%}U{Nm7`6qSK&RiwN_y zu34cZzhFsXzx%iMF&N)Z7um}-(v@_2m_rP{+&!Ckz5R|U6O=f;dVYYK%&;?(QQv`I zdhFiN9{lsUUqQ{~_atx?S^94Zk!C@$ zGv=#gRV54st;<4!pw~&nUF`FI7A0orrfHRR#&zU6QTeM1N(IPpTT)!>v+L#2m<^q- z>Un2j7j>CwT46c40NI@u(y9F)Or(lc%(Y4KFA(USsl}H13aa`OqI)KS>g1ig!}0fc z?TBZp61COtP+QogWbD0_qH2vr7rxfyX0Tu^AGbId8}BH+R~_Rrp;_~?JF{;#iy9}kE|$+7?t$o2V;9F(2?1UvhS3RgJIX5 zFF9NCm4e$7;YqJk-1_D;)>IwXjX`Vr9O1=`{jNl>1~(bZNhEc`V~-h=4l?CFY0x>D z)21t|doF+KVBy}~;?r~kO?SF7nRq@`-CG<<4lO=aV{_FhVvp^Qq_8#_^x>lRvfQ z=AAtoU1pl+woFQn3l2CQhYAxaWn41g0B9P3bC zmLcmu>Xay+R4z!91evmlU6CwBaHxhdks7HpOFyxdyZw{@4!gC)^ldX5>iJu};akY( zGoLn>D4QYs?`Z_O%@%^sai3aJQ}#r5C+MRBI#3K3=Xfl|Bd8k)w}n${a1GrcEX;r`dis78Yy6umCx-BY?q7F_q-qPp`}w*P%)%Ies(c1s#;tZ zc;^hQb*@2#lV5NU`@UPUBt_r&ktjvKclks(Z`+)cy{?u=)z3JRUg@{ew6Y!yKivE? zLaSzdw8Xxn4!=$rt~On#T3!=>ZP_H1fXWy=c}BS)&}+))sn{x-*lW%w0e$IsmYI8q z7^LrH7O~;putSGbE%?;L0&>Oe6Z_rueO?9$Hk&Ibw~R5d$Ls@c@u)$RYbdcR>}~r6 z)PO^qRGDY5gGTx1lT^xJq4%_@>&K#z@82!|?3HNi)TJ``;-gBHQ;?4sHP1N+8w?6` zMrCxLJRimz+rRdVBHtvPP?xR84<_iF6KQ7cB*Nb|H0eF z>xkNVaaBkYnfk`ExFsg-=QS2*-6bE7%9vT7X?kkcjuzInrqhF*fTah)!c0DPM%e81 z=jExWULC4l=brq9NXyQanZ@c0c5aWas9fmHrQ0r_b)`hLUFkUAT)`t)%C>ms^5Tjw z=|~u@jR<+I4b70aWrhCOxUVZY?iCS2kjd_*=Vp~+K9Q9?3MyUMcM*GIofa&Z&;X>3A%dK6_p6uDWQ#dt~0$u!QdJ$cB2(+KbmZ_ih+HnVcW>FQ&3UZV?Z z7M|EF?0;MP`k8qd;jw_vQ_xQW$bc-Gg_OFZ^#!h$gQEI)kv2u={ z<$TGvVA9sJG%L=i9xL&1#EP*pwppDqEG|5uk0bAfMnqJOv_YoPHvA=|eM5)&!$&*w z#)fxB^m3X@4WB7{W=Z(O)DjLDn^MD{YSE#K7bk|2H&yj9YfJA3`Q90K=uU+6BLJ`H z^5?eaO82_>p~^7wWJRL_gW3LZPSTx9ftX(n@K=r(w6$VKy=HCcDiX#$BK=M3Li6bh zaw4x4j`uI>VzT%npl5V#N-Fy$`*>Aprj3s|pD3j<@xT4X*@xb=F68zN26ut@Hag0# z!YBmEOtFkSjVEB-kE*n)xN^r|MV}_@e6ueb1CNNhbS|3~jhLQeRGc_{j8){Oj#s!% zcddtG(^~5Nldl;`mE{sn#eZY?R3Sk7tiTAiM!rDX-MmPNj^fzgxzX-*c+Xs`p4*V} zUD|Ws^XEfD7pqFq`Wd<2hrO&g?wlccryH?eto&Po8<1xCg=8R@2q?&6x>>l=RfFCSmvv3|xC-T*U;nf}; zsi)A_DlH6e+1OaS**os^tCq*Rt5b()E*Gb}K5M0HO)R+nRArxKExNzzvgQ3VD`3iG zS;g^D206h~?re!`5(ln@%1VmQtt(;7KQeE82+zt^3Cud7qOblVvH_+Tth^Nvfb`@m z%G6Yx9t~{|!Q27U7X8q9KB1*T@dzx946td8%W1Y6m8qzM6tQ6FM>p$HB00qMX(Qwc z({t;Y31w9biNP;g%6RQ}9eo2CFPu_7@H_3usY#Wl=|Hp-ps4g!r;^K2y-Un!bkFab zITbqn;WY+P5%vD5u1=k*K2eu^1-HFQ%SokOD)8$<@WLy~h@GW*5nZOG5Y;C81OCl3 z<^7)Z=C|rok#HC1fQhr_FSJUN8!dma)@H4=!Z0-=miEte2HVH<*OL>?_|@nO4D7OY zZ8hV~WF%cU_UyXMWyD?Hiofk9v8AV~(+FEFnQ3gf_$7VXtvFy0WpdioO3_uCg4;9q9ytHGq zFZ>@yjLpJEB-)LkVxsp}h3Z&^}kG0Hqd-7nDvj zrVXcl)*jDA2@;cD-HMH-6}aACRJFm5LdjCG@A~at70c^kIq|)^g4{Ybr^C9ss-jMS zpStt&$s~GVj5^oGldU%-ujr@S=+BvxarbYuwO46KjeR*$s*L!qsSIucdCG%lW=%vW zg~dBwuXuWNynTb2c)I1ixlvg=xhTI&my$>Kb5qbRO~|0IQ$^Wo>p1OM!OXD^LrI04 zC63(}rzZLzSEx;sRo#p5N;ruQtqrJ6nPHnF@q22SZu!0}BaKnv<#HtaLu^8}AJvw< zOHtiTFCDL&gZ11kaW#=wP73-d&0k>$=jJI~tyHTA_vK&z8m16l8@3nTDAZs%aGP<; zd`46j^^Qa@+&!#ff<&Y3G( zQ2XE5u2k_8Jo5w1`fz_~UyJlv+!&AEUkb$aADKa#Nl`^dxj+;>6~wcdQiVWd-k8 zuhnb)np0zDx?J8ec-{HY#kkJacn629amTrbTn`!dQeZrz8GX_+DURvs5)U*?cnWzG zpNF`e2XEx%CoOxgl9Xm!j8>bZx0bNDU3H;#&iz{BM{g*tNUDp&Ans7P;?6jC1NOuvE^l-^9 zS`2ehU3MEK4SiOWI`)iZ%kG8JV}rwG|4Aja11j!i71B}{N$!>>9+q)2&y{Ar?TwS( za5@~lrHq&YbK5w*;c7F^i|IDar=IDwQ~gZp?dbJ2=R0ERJogva?4k(f z!h$h3(BxlqF5jdiKndlR{PZ$WjoLG|3gHX=c304gFV@W$M7w)Z_ak`*MYw05yhYtw zah5yZHJ>3Z@=QPLoIv55z4PZjX)at?AmuiiIwha_GUjUqpL2HzWP9HFvJrWKZZDU) zL$uikGWfPdrc%LohQ|!d^uctDOBNTshC@9w(hj*?A6yuLePk=mNf#FCWbCk>gmdIg zMh*+?iPSxOB4HH%O?)OoX34pFcaVAf+n0+>D7|#{?fd55%Yj?nbK(}V&t;iOb(Nrp zAJSK{(CAh7NtCW-Z$Pj~qJX^1{_?C|yYfBuO5pzx10Bf;-fPjCZ7-Gb;wmgpY}^b! zq{zD;FKn7=J}t7rbhRvQaHBH}5^9p=ofM>;XsJ|bTq5L?#_qp=<6QF;FTPO~{F|S7 z1Zst~lm7K>|HsGuANRT>A@@2E@c&|5hd>1ofQ4EZ@TmV^8rK1Xv;Y=pcEq+01qlct zg#d##5-?|jp)eunQP=u^;GzHeV6n6>yz9nyt^bEF`ma^@e;9>7-roP8hIQbYK!1JY z23YtRfb#uo69*u8dQgNg&>isG-3|a}_5Qfd0kb>&U;FxB(>n-YZ4xlG1CVCDzg~3E zKQ4LrA1C|Y#DCxatN!)4|8o)pEUy!QbN)Rzz~t0}0u02z%HN;RBuFJF<-TRw`hIkeEo_K@fE$H{_ni-()#%k`!vc` z24oh*BodUY`S`)+d2O0qjkW1ntq$=I-g}G%0?)Rs`JK5NL@8!oNQ<0ZiOM>u`cf)H zSCF@tD*Qbcx%)F5@E>eg zgdu_3`_Em9=fM9TZtMSJ^ZjpnAddO|H(T=WL&x=zxdj=(^M=64K!08U-4+Uf4J|JH z(XdEL?CX;4e`{a_7FByx1A(!~UtA5#Gsn?{ux#`rnh;C~`#e0N2_qm_+W8R;fV^W_ z|3@{T1qr}_AJM>Y1Qv06RD(dVC{tVw3l_)GAXuC>jt0VlmXBy4Az>^)7e^DqVq)Ky_~%6s$R$u$ z2m*D5AW&Bb0(FHTP*(^7b%h{MR|o=i1@w&KT?djtT_Fk770{ZBpG%;wkOb-qNuaKf z1nLS&pss*R!#yv6z{dN20a`ZxcZ9^RD}a1WAQ!)`0G>91^TP4wWS~h7?^y?6wDEHR zS~l)82S8%u%_#r^9q;)J%)WTfae#!4H}3<`Y`pmcpjujb`okx!+EQDog<7mGj(Ks3ie@!C{#bT~;;vm>wOdL%ZiwMWj;CO2v07Z=@ zb>qY#@#Zq1G_Z{7qj3-d*9OJ55#z)`L3nE<;LgXJYrzO$gBaXg#BX@{k@E^c!FX#z zAt(g9l@CrF0lP15n&*)+lU4 uEYLcSMS}zV=)h26!Qj7J#(~5925&n!8b5OUy-pWKK%qipoSZVsvi}A5Fz?X- literal 0 HcmV?d00001 From 1a5310824f70343828885ac33d1f77fc3a2496a0 Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 22:47:36 -0400 Subject: [PATCH 39/46] Updated UML --- Scientific Calculator (1).pdf | Bin 0 -> 41091 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Scientific Calculator (1).pdf diff --git a/Scientific Calculator (1).pdf b/Scientific Calculator (1).pdf new file mode 100644 index 0000000000000000000000000000000000000000..61d859149efdcc47da80630b5c2cd8a124cfbf48 GIT binary patch literal 41091 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 g((h&8K#6|Cvu*7Rp4dTNGeGEKc{Vc0ssI2 literal 0 HcmV?d00001 From 51bbd3fb54ae42a8546b3d1f504866010121d64e Mon Sep 17 00:00:00 2001 From: Fitru <51715717+tfitru@users.noreply.github.com> Date: Sun, 26 Jun 2022 22:49:28 -0400 Subject: [PATCH 40/46] Deleting Old UML file --- Scientific Calculator.pdf | Bin 41552 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 Scientific Calculator.pdf diff --git a/Scientific Calculator.pdf b/Scientific Calculator.pdf deleted file mode 100644 index 3c8462febd78941230a8e595a9b21569f06a6db4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 41552 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 From 1d446929caddfb51f804cb1ec4e3c7d8bbd3c97d Mon Sep 17 00:00:00 2001 From: Fitru Date: Sun, 26 Jun 2022 22:57:26 -0400 Subject: [PATCH 41/46] Added a missing letter for input string --- .DS_Store | Bin 6148 -> 6148 bytes Scientific Calculator.pdf | Bin 41552 -> 0 bytes .../scientificcalculator/Console.java | 2 +- 3 files changed, 1 insertion(+), 1 deletion(-) delete mode 100644 Scientific Calculator.pdf diff --git a/.DS_Store b/.DS_Store index 4092bab25c427ff270123ef7d6da4ec9af935d3c..e3f0354eab14edccb9414b02d968e0763242fa38 100644 GIT binary patch delta 104 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 diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index bc5ef88..504dc00 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -30,7 +30,7 @@ public void calcRun() { System.out.println("Type the function within the ()."); System.out.println("For addition(+), subtraction(-), division(/), or multiplication(*)"); System.out.println("For the square(**), square-root(**/), cube(***), cube-root(***/), switch-sign(+/-) or factorial(fac)"); - System.out.println("For the inverse, sine, cosine, tan, invsine, incosine or invtangent, write as they are presented"); + System.out.println("For the inverse, sine, cosine, tan, invsine, invcosine or invtangent, write as they are presented"); System.out.println(); // print enter number From b42e37d588e648b27303c6e828fdb55112d0c7ee Mon Sep 17 00:00:00 2001 From: Fitru Date: Mon, 27 Jun 2022 08:20:18 -0400 Subject: [PATCH 42/46] Added extra features --- .../scientificcalculator/Console.java | 4 +-- .../scientificcalculator/CubeFeatures.java | 10 ++++++++ .../CubeRootFeatures.java | 12 +++++++++ .../ScientificFeatures.java | 9 +------ .../scientificcalculator/Console.class | Bin 6591 -> 6852 bytes .../scientificcalculator/CubeFeatures.class | Bin 0 -> 486 bytes .../CubeRootFeatures.class | Bin 0 -> 535 bytes .../MainApplication.class | Bin 648 -> 648 bytes .../ScientificFeatures.class | Bin 2698 -> 2486 bytes .../CubeFeaturesTest.class | Bin 0 -> 884 bytes .../CubeRootFeaturesTest.class | Bin 0 -> 912 bytes .../ScientificFeaturesTest.class | Bin 4339 -> 3633 bytes .../CubeFeaturesTest.java | 18 +++++++++++++ .../CubeRootFeaturesTest.java | 18 +++++++++++++ .../ScientificFeaturesTest.java | 24 ++---------------- 15 files changed, 63 insertions(+), 32 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.java create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeFeatures.class create mode 100644 src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.class create mode 100644 src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.class create mode 100644 src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeRootFeaturesTest.class create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.java create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/CubeRootFeaturesTest.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 504dc00..5163bf2 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -110,12 +110,12 @@ public void calcRun() { System.out.println(squareFormulaPrint); break; case "***": - ScientificFeatures cubeFormula = new ScientificFeatures(); + CubeFeatures cubeFormula = new CubeFeatures(); String cubeFormulaPrint = String.valueOf(cubeFormula.cube(firstNumber)); System.out.println(cubeFormulaPrint); break; case "***/": - ScientificFeatures cubeRtFormula = new ScientificFeatures(); + CubeRootFeatures cubeRtFormula = new CubeRootFeatures(); String cubeRtFormulaPrint = String.valueOf(cubeRtFormula.cubeRoot(firstNumber)); System.out.println(cubeRtFormulaPrint); break; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java new file mode 100644 index 0000000..5a857c5 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java @@ -0,0 +1,10 @@ +package com.zipcodewilmington.scientificcalculator; + +public class CubeFeatures { + private double result; + public double cube(double number1) { + result = number1 * number1 * number1; + return result; + } + +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.java new file mode 100644 index 0000000..a2a89a2 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.java @@ -0,0 +1,12 @@ +package com.zipcodewilmington.scientificcalculator; + +public class CubeRootFeatures { + + private double result; + + public double cubeRoot(double num1) { + result = Math.cbrt(num1); + return result; + } + +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 2ef5e91..5edcd02 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -100,15 +100,8 @@ public double inverseLn(double num1) { return result; } - public double cubeRoot(double num1) { - result = Math.cbrt(num1); - return result; - } - public double cube(double number1) { - result = number1 * number1 * number1; - return result; - } + } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index 564bce1e00bfed178d45d1691e5c32f203a6f63c..dfc7cddfc6d58515eeeeb2058507509c7170fbdf 100644 GIT binary patch delta 1735 zcmZXUdsGxv9LK*i_ukoMXAoFW7+-~gh-n@(&DJ!P6CI9C))u7%q;I| zSc-fJJe^z{3MKTXsGlB&WoG956E8611t`|A+>G1JxS4Pu1|=F+n4%+lhBqgD!fORyk1^MGmd!vR;m?c5=`f@#4*`DEE zpU2cIG*p^;Xp5edncd=S*09BNTD3SM+`bHtulbBs8n&8;2^sHB&&ka4x+mLFoo|bl zwiz+DptWwZTB;rU1Escj*_dj-U;Ebw>~GYC#7hH=Y4#rB z|NB_|1D8VD$O8`$ke;9!w2E$3kSeH=QAbs279BW9y=Dbak3;k%A*tCt5O`EO!X7Y2 zRbjEqsXM!E#=}7@*^1e&$V#-=BZKHvCbzCZ0VRrDQF@e>SY`|kkCxsyMuo>pD~*{{ zOO0ZxWkxO4wMG-w^#+R=B5g2|sg@h_s0NINh**EnoZi)(-qoCrWNMusQERR>wCX&F zWLKh|=-eJeZ2{D7Yzu5<=s?OIOVLFTgUg_rTlU?xRne8Zwkm&Z4gJqvBhUGyRA=mW zKI`u*FG4@L7%sUKkH{M^NG`_!xe^2AY7CYeFhp)dl6(@6$>;F6d=W$CYj{e&jwj?B zNRe+Nm4)GH7L8|ETMT2JF@oKP=U8uyW_^*y`e7s+gy-2Xyue0d3>$;7Y&_h|hjf;U z43_7|i)@`eai{WL(n8->nnXSbXRs|ocMJC&gY3vZP*lA?5Cgia5$YobBgWbYQ zoFR`Zn8_pYGH-`hct`ko0$$~PFpCesY(5Bc_)xsg(=eBh#T$Ga=J82*ljq?rJ_~Pi z{~XNc@8Dftgav#R7V_0F_$Dmk+p(DM!xCPHrTi!g`DrZUO(@~#QOqx3Ilqb(0$3^R zSS3`HiYSzc_E;<8ut6kXok+xb(F+?z5;lnxl#5hUiZpB%V-XY?s1_4ZB_?C5U*w=h z%*8e_AKS%3)QUpv6l<_clw-FDV6Ujbez6A!L_O+6BMyqQs23M-NLOMHJH8ej+VFtbsZb*GcS3bi3nc>Jo{i)hU=K*5d|gbjK-uTCT8gB_22N3te?F lN(cN(V;JI;2>eDGM-Ro0-|4CoxD~kEra`v-(R?f3{u4sN#w7p% delta 1684 zcmZXUdr%cs9LK-A=bYtwcL}*bu%IRa3KltxQF$9p!<-OvN^?jXA4rJ!;OZ4|$j0ld zhfQj_DhiRBBKQWbf^Z(wU~o>9=>WnZ|#1fA{nKp0oGvXYOf8 ztm|(-^{~1Yz#u#*w|^!}lZ-;SpSMwdi+St_!x{~1v04I8pF26j1o;})o4{s*Q7%`G z2@5n7n$SLHURF-})X`a)*(NU1@P&nE&rNgx*WRQd6RXX_mm0FHX{(0m*0fE-OyBeZ zN;Pc9A_;0%c5a4yPR8i0Y~Od-sbQDN{X2P*YffjfN5fuYykBU1xrPe!(OssbrRTWZ zS!pwD*eAh}oSp7+yED>rdb(z1xYH=Iq0-pwmmF|Ff;85S6jW=d!B@s#e(|Chd0_hCRKj00Hg45~mkJ*X1BO5~6lSdCyk*lMgZ8zE*R#B50S;w`?x zm=G8#eQqoajEvf7cEZh0xUZA{XqN~*!fJ0e8mPU+Xs2tjVRO79l^7{>-C?Yt>u%$$ zBhpi5?h?_TSvIDyTuftm9%Qoln97!5I$MhwtOzsNCb-yk%wkoT z&FbK0^~hn3n9Ev`%dTS{YeOEph4FNDFjU=81fb$l=K`5~<5$FPB) zKp{ViBHoIP{5rPqHf-YU*vvbyRRG1phHXMcsR+gn(G9yqG|EID>=tp@BN9+9l29R1 z;1wgWU!KY{ctj3r#fPX9D{xq>LcJ)!QBjHpQHEo}i{qjOC&f{m z5~t88&Y?+M#%a-xGok~{;sMT!hiFj*E+_$LRYGx5iNqx(4p)=}TveXKb@NXn-9!Rh z@W*Zj;9el$hVFk2|h*ERs2N7p5)m2CB4YL6K#}6l5Z71Q`(E{T4^+SccPur zC^D_$7fPeatCjX9<4)Y5G=>zb_?6P$qJWzW)0D_yjP-VGRyk4<#RER0Ns}`5=Qx#`EAZTxgXERL)IovY~+6 z?aiv#Le)df$2NR{6P2ujCv&fo8~tdam5JwB5(jH#bex%6qm+zP9?2|8gHaypiI!QO z>NTmg-a60{``56rrFT>Cs z_h|3Mh37z^c9rC*(i3CNTYqnSYzKoQKHuTs1eF8e%Hf)mqwX*Z7zJaw{|@m|Y}cuF z8*tH}`o9OzM2i`ph&`%po)F|R*882#va@`H*MEig%!&g`v0r6bRd@xdUF7u*iGA2F K=mG~tPx}WQSY*rq literal 0 HcmV?d00001 diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeRootFeatures.class new file mode 100644 index 0000000000000000000000000000000000000000..841f745791953f692c22700c6cd201a90e288450 GIT binary patch literal 535 zcmbtRO;5r=5PjPg3blNQf}a;p0tXwM|uYNCewc3ojfKTO$b;-4}m8jS~kfIrGO ztt2L1y}a3(oq6-}=JV_Q13(|U4h)z!EEfe78R~O>$Gw0@Q}5iLOQ9KxM=Daf&tSGY z69*-fZ8$Dg;4)Ny+fTWkF<8P+XvS&}JHs-nsM)BySVe=OC*sh1P`4t!miH3{7WV6YdY=Th{Jcyz!u8NW+(EZ*pk*L}OcOywC1yk*BLcZBkW)NM)3zEA zcRu~*04vc;FHQ+INGMaFOo3YQP|mQ{r_4B~T1$$x#Ve;%#CP)eEWP=mHv6ebIj(%t zIwa37)S+AQj0r|ec=mE-EFdd;NNNA0OmgLMg)&LX)IZ8qjI+Ty&w<2fxkLTbsR37+ za3>QL*+#L(KSvbnbn=mUgELxmnUN;OPz^@@4`Y)v&MFugVvN;bl=EOTmd6(F!n?jg zGwTgnqiklZf_AiF8#`_-8Bt3{nw|k)(>HYG3#~+&3F*;2zgek4ji<5}|h#Ds0%Dw81RPcG5M|Nwf48Gmv)9>S=omp=H*X!}rXz z)oD~s963SL8eJ5W{<>Y8Iy+FDaFZ&AiW*&^tB~BZ_c0+?Le@opNuxQjB!ndc#s0^! z&xUVtF|er7l2l|=hHI=^N6%o{h9}k;gdz4iRcD*S4VTOR%TCkq zQ~O?rwXltfQ%)%qbK_Oph6!TreeM|B6<)&~hPkz8w%V8)uQ<%uU1rTgF-SVPk9iX+ zGK$#ErrqWa24dUyo3>+G9l6+>HH$&9D#A8*m;v*{!QRjsib-}v{TqSbIer%b^Cp$; znnHcTT+zcGv?E5RYP#Z8(S&UG_QcUDcBf^S^IT;0#M8w!DNGDMM^NBIfQyPnYY=Ue zI=L)T zzd`IW#LFTo6t9KkjL2B?ID&gqvK3nOiF4oyVqDK2P&@#cz?qU=$heP;`^buqocBZ~ z^z1MV1<4$O(BUp-!e=IY=9{465rAB!RLRZ@kbPqnK(>GNTzfI zYludXjxmbUNwiMUINlwRVmCDzf6t7!=X)4asc%$8+SmQv7rZ2;M3P=QpqB&kG=UpG z)5TBu{FHwtyhC7%%ltPrA3)86sy~B@*DQegY5;W-)WS2Ux9F-zy@_0kY$o+=-aep0 z0Q4N3cV0r%(p5=60ZF>;`8r7(XoUcNKM4PN0R95-(*gJop2B|^gg+mEF9Lrh0RKe2 z*hr}V$WQs#u$YSE6!j#?*~AxLxz>DJS~CZ)en}a1X8b`GBV+moidHyv{K2k)`JaZA zM}Plz)VdiI9FZubcX3S%uMIY0g}aYlG2Ci5{l(=0QEMGwb4cGRVmD; z9uYblfV=~tce{|igjRiIx6t|j5Nbf^W*4=WP{XGl5xNi{bQ?l>7qXYoO&{6ynr3$c YAN@LB(?%Dw`!zLXWhk_Td+DRvKW?L;7XSbN diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/CubeFeaturesTest.class new file mode 100644 index 0000000000000000000000000000000000000000..813e0856cb21160e518f36d78195ab0bd59ca291 GIT binary patch literal 884 zcmbtS%Wl(95Ir|Bwh1OLr8I4M6v`uM5f%~>iVCGwOc7E9QYn#GI?g5B$gzVTfXbE) zKZC@EB9Qn1{(>JtoNFqTb@5_mJacExna9uH-+lnt!p#awC|fWboPsG(pZafnH}s>4 z`*bvwK_+0{Q<2KH1j?Q6(1I;+H;8BMftm;LSiV)^OhuC{j@&d*GRo9T6$E}5Q6K)mhn! ziXLtY2v49Y-_5yVIo^|L9_m$dNrkbrmvfUdIaH})dpl7SXMU#Qh~1qZ9M6B6&s8Q9 z*Pkm_vm-?1S)3<<+*Nu?3;(WPKe(mu3#(Y>+38P99v)bhmP;+PXZ;Z3a}mBksl$Mc zi z_fp?Y!pLc*ec27eWM8^T8p${h3t4k-jqE(;9zJIN{CxjGy9+joC<)}eS&o2FZ#UZJ z?%TuP_diwMGgKItwpa2>@Fbs zK*lU?wAimep`!x%Fdg@0bl~=Vddi)U9rxTw>HnG2NS-T7Xm%Fl-DXz_`R5O*`|gig zeBmd-fD)$C?k>VY1}m8Mb4x(91(xLN2}dsnT^XmoUI7kn3ToYy6CTT+iWOUJ20@s( zi3$UDdaiRkk5M{NiHsa~q8zP|6#2(t8hLVG=@+ZbyP2pE2)pRTuQJs zk;AXho{b}j&(rXES{(**xIkSNWTMU-ExN(4zy@swoBsf?`{LXH literal 0 HcmV?d00001 diff --git a/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class b/src/out/test/test/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.class index 70df731f672c6c22b5241cb90ef40cd9a753e32d..ba275cc4aadbd5e630a1467f28f71b3e6e45b369 100644 GIT binary patch literal 3633 zcmbu=TTC2P7zglgV40=Mv`{VrrB+&F3)H$TZ7QwEE@8o<3mA5x_Cn3DpL{dM7cVgy|7T`)c4N=5P1sFl=bZDM z^E+qG`DVZU_lvKHsE0lbQ5ls7DIie=i2~K6<#{=rk@czYNGh!=mOx^+rfXJ@K;>=i z<3Xwv=wZc}2`_51ig8+9&@wZcK4lqt*iX#k$gj7)|GcT;6V|X-qJ4IQCF|&+etO`ev0Gwv&{?k-J#pT?W1)v6I!q48gQk2CEO7tk3+J;G4!TxD-MvR`y??aG=B^t43o-wAx$j=kMAHCWquzm@NlB^-* zjvYsP^v|@njwd8K#@fp=Sn*#sdjI%kc|YqnA<-$@%lFg8Xll7@Wp@9iAf*KAUDsJl zswPfwpbrOCpz1iD-EeLurDl_IDubHZxPhZOE@PP}yOjZJTEn5~i?3V8qYkkdB-~@| zo;qhzk@by_v4hSbP6{N%1Zp15A^B$1an01Qm|k5sEZNP6t#N+Nu$i#)P?#jk2vii( z!eS4s9nH|3vIlLwLWDh^vB97{3C3D>|-`@ELB(=rpdZnW&0XTqP%f zCTR*KqG`02*_~4qz?Z1$O9~#lMjPV0>nXHK(qKK+v|Xp#!g#fITn$yyW=x=#8mZ16 zyOqjWe|PLkv}u%v$0E;A2F?uH*=%(D5*cgSHLKJFJH)daF=7+OZHB$Y$DUo&o?Fw# zx?5mx)9q}-Bu~P752S6dnfE&u-jmF_}Dqmp6A#LrR@7)xAE*S z?7gt}!S3|2&wBPbj=fmQ?ts0AXCH+9AnY#KhkfiN&wh$yKV8ZW!|vqSJ+LFNqp*8@ z>}NdtS&n_)vsEN3%dwWC96L}?2Un>Jd^eBp2S0!WdjtplND<%SrCA+au=zSfKF8so zzXQGpd@qlWW6&Y+!{A4J_=_I@0*8O`4){Ls13W$fJ_&vd{J0PQlE=Ty;a~B1pBLN_ z*pKn-7f#=pj~UoT}3!G4@)%dk_h71*kez3kbSIQAQ*>`~Zb zJX?dEhJ6Nh#>alsv)|&_Z~}o-U5~pXe WVK4dE?|Jt7x7h-HfYdIdmHz-)lEpv( literal 4339 zcmb`KTW}Lq7{|YD(@h8qEp328K?@Aff*5Xt6tPLCrBDs6)3inIv)OLThIF?i8!oNN zMUwFBS6P z0QmSYX@o!{sTicxrnH!pIr3CBR5$S98r!9e0$v&|&=?xaQKgpb4#v}{3C~_dmy~n?%PZMZ5GkQ{r3d=ytt-;TB7BI_9fgWI%LP<;U zp`UJleXV@-d1ja`&>X{{iz*`IOY_gR-{!+j=6w0^>K(?2xz-4@h#ux>xP^`aV$G<5 z4}CZHkH2osy1*Pm0)?652+OfvGwb>J?$;j=&SP^PMV#||z$-8=6PA6_4J;yVSBnV(Ne z$7Hr{ylEri!*ac*(Syk(3D0r^h<|` zcMaK6dh`tnDy@&)Ga2jcXB9-P-mkirpUI{#R(KF!ehMiUOEWU}J z8Zj-PmK0aV+wd<2fz|d(V*Uy+g7w?+UQ*b7M~g`#!Mm2YXTu_CANb-(}th z^06zyp5n%y3idRxr-NOcgZ;e2KIp?${Q5bW7t&jEXG4)$S(eZ+-*G#`5g z*t6W&3&4H|?1f-2%E3P7u#da2Pvm0;b{Oos9PE=0`vn*Fiw;{xv$7tm z$m+5A0a`FX3xQwkhF=1FBl>(PevB^5!dEzLRz{}`d>K4XyWr2<1-=&eIyZa-NtXlP z417xt{7Vl0Wf%O}yTI22-{^*q0^bIFJMbMj@UJ-dS6%S0Irtn0+%m8qb7QXpdo>n* z4HkZF7CZZZJLfF?c^CGDeC*|5KkmjB!H$6~fi34?Uv${7yRhHL$8H6?-Hok)9S3_O z*ohqMHy!pR7xr8E*ek$Z<;Ly>dlT46u=O15w;lF7F6?*nvDbjT-i^H#>}_E8f!&{j z{hq_V?81J3NVYgY64 Date: Mon, 27 Jun 2022 08:27:55 -0400 Subject: [PATCH 43/46] Cleaned up the program --- .../scientificcalculator/Console.java | 5 +++-- .../scientificcalculator/CubeFeatures.java | 1 + .../ScientificFeatures.java | 3 --- .../scientificcalculator/Console.class | Bin 6852 -> 6723 bytes .../ScientificFeaturesTest.java | 5 ----- 5 files changed, 4 insertions(+), 10 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 5163bf2..67e3e5d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -12,15 +12,15 @@ public class Console { private boolean onButton; private double firstNumber; private double secondNumber; + private String operator; public void calcRun() { onButton = true; - String operator; Scanner Calculator = new Scanner(System.in); - ScientificFeatures switchSignFormula = new ScientificFeatures(); + Scanner inputEsc = new Scanner(System.in); Console reRun = new Console(); @@ -120,6 +120,7 @@ public void calcRun() { System.out.println(cubeRtFormulaPrint); break; case "+/-": + ScientificFeatures switchSignFormula = new ScientificFeatures(); String switchSignFormulaRead = String.valueOf(switchSignFormula.switchSign(firstNumber)); System.out.println(switchSignFormulaRead); break; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java index 5a857c5..498c038 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/CubeFeatures.java @@ -2,6 +2,7 @@ public class CubeFeatures { private double result; + public double cube(double number1) { result = number1 * number1 * number1; return result; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java index 5edcd02..c1e1360 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificFeatures.java @@ -101,7 +101,4 @@ public double inverseLn(double num1) { } - - - } diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index dfc7cddfc6d58515eeeeb2058507509c7170fbdf..26b85cdd85b6b8c1f270614cb2dab89aa7865393 100644 GIT binary patch literal 6723 zcmb7J3wTu3wf@hXb7oFvPRJx7k;8LBcw`b_yrNhKm6ilr5DEZM9fy>#cfgpSQNRm0Re)&Y1^<__fK$ zp1s#v|Ni%5t-bc1;ps#B9s_W?f-nM5L(oj<2r7tfv^Uv_w4K?IICI@bCsj}oJk`y( z1wz%f_}Us6s0kr#A_7yv38`#<;!<}YmF;ylyXk&6v!Rg9B=RZO$rRl6ZYpJ`Q^mAh z$mSBA*-Sp0b`%)d%;I8!I0ef2A&gT{?~Ph4xamZ9%Fbk*Tn(bA523+CBgP*!t?t2m z!Rc2JaM{0Uh1b)~CYEIeiiPe%&awL!hEa=VSg3y5Qre*S_sd>B2sdMud#@8B{rC{;WY%XT^_PR1kTSt6OEMHt#$l2bgZF4F2 zx|`g*7!wo-?k}bb?m*g2*#N4*eeIzJ+K{Zz3qe!hY8*ki7N^I0VfT)?W`z=b@n?W`{%FT>2hITS4cFOzR3?K>Gv@cSK;HF1P?W1 zv#qNu-X;5bjfqd-S}tUhoh~|Oaub@`x<>J`a9nTVlfq$?bAc#tFma3gj*DxHiqSPR}y!1(OaR0u@#>+u?@E|0{ryB5jasElRL(^q0BE;?%Rd?c6{E% zox-h2_6gw&3KouG(w*$IhRLi-yF+Mq;BFK52(2Nsf{=CGYhtG;!+v7xW?mEZkcsrzZw1R0z4J%hqdCqC4z?sm=euAl6!7cI+$l11+ zk{ecJng7<>yjUoglo~HsrkfL2j3pramj)BKVk?;LXF~6FF?tp!u @*3mGVYgGp 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 diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java index f22a042..db14c1c 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ScientificFeaturesTest.java @@ -123,9 +123,4 @@ void TestInverseLn() { } - - - - - } \ No newline at end of file From 4afe29448d09a8f1a7658177ccd46d3947841ad5 Mon Sep 17 00:00:00 2001 From: kchiev215 <105018363+kchiev215@users.noreply.github.com> Date: Mon, 27 Jun 2022 08:38:33 -0400 Subject: [PATCH 44/46] Add files via upload --- Scientific Calculator.pdf | Bin 0 -> 44547 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Scientific Calculator.pdf diff --git a/Scientific Calculator.pdf b/Scientific Calculator.pdf new file mode 100644 index 0000000000000000000000000000000000000000..6ee7a09442a1f1e9e382497edd9b090b42c43ac1 GIT binary patch literal 44547 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 literal 0 HcmV?d00001 From 98503ca3d3179bd00cbc888eaeae19019b830c25 Mon Sep 17 00:00:00 2001 From: kchiev215 <105018363+kchiev215@users.noreply.github.com> Date: Mon, 27 Jun 2022 08:38:45 -0400 Subject: [PATCH 45/46] Delete Scientific Calculator (1).pdf --- Scientific Calculator (1).pdf | Bin 41091 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 Scientific Calculator (1).pdf diff --git a/Scientific Calculator (1).pdf b/Scientific Calculator (1).pdf deleted file mode 100644 index 61d859149efdcc47da80630b5c2cd8a124cfbf48..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 41091 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 g((h&8K#6|Cvu*7Rp4dTNGeGEKc{Vc0ssI2 From ab07dabf61d077505dbce1cac3ebcda0e72f3ba5 Mon Sep 17 00:00:00 2001 From: Fitru Date: Mon, 27 Jun 2022 08:58:51 -0400 Subject: [PATCH 46/46] Fixed inverse --- .../scientificcalculator/Console.java | 8 +++++++- .../scientificcalculator/Console.class | Bin 6723 -> 6926 bytes .../scientificcalculator/CubeFeatures.class | Bin 486 -> 486 bytes 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 67e3e5d..109fe0e 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -132,7 +132,13 @@ public void calcRun() { case "inverse": ScientificFeatures inverseFormula = new ScientificFeatures(); String inverseFormulaRead = String.valueOf(inverseFormula.inverse(firstNumber)); - System.out.println(inverseFormulaRead); + if(inverseFormula.equals("0")) + try { + System.out.println(inverseFormulaRead); + } catch (Exception e) { + System.out.println("Err"); + + } break; case "sine": ScientificFeatures sineFormula = new ScientificFeatures(); diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/Console.class index 26b85cdd85b6b8c1f270614cb2dab89aa7865393..9b1d1e6ea86c46c569273bce3ec32592c2ad76a7 100644 GIT binary patch delta 1924 zcmZvde{fXQ6~{mK-FtU8`!*z549O!P2{GlD5wwcVwxkeBI|QrNQVOjif|^vV+u7Uio?_}YZd)x*UqaQJ*PH3YxJa+ zWU8ULu09>1U7;s6Hbz-WM~vAl526h*=47L;80l>ERE&+>rf}=h^HPmXsUOv)Q$g<2 zF`fzZ+|Tui^-X~@MXb#+wggtc&#kHQ>{PlrsCqWWHkK=LZm3N**EiPH&WZ4xB0f2t ztZ!^gC7Vm@8&Zw6Vnukt-xZ#mw^QC`MwCn06=OGh{PIX;WS?l4McCglJu+AiR4GN_ zrC;-w-|A>`SE-tpCIQ&`GP@fp(fW)zE0)OEZxl@eqbEPjdaZxf=ZU^QzSZ|NQ*wXm2;S%;;i% zBI<9+Kg+*6ze08UUHR3j#qY^4Q`7uG1!d|&zp9|rapL~Wg0g8JcC%C}S`!1j0VCHl zwv&gSWKp7M9iCUz$&fa+_x~BiUU4?#(ICU~isOIk%<2yQe@jl#rUZ|2Sx0g<7cfNf zN~xxd8d0yHg6ZPSW31>xyZ#%0P?>xddXEjyM zIwm;VsdjcV(b>l&=OEvA-ej`#Ha~FQrN()WDb6Qcro&vW^SDCCxl)%fRhKhOkK(8L zJbt3bFkN55&vXq}=_|Qf|Cnp_HPq@GNa{4R^jxmjO{DY!Zq%72)ahl+*7q_;Kgi8` zEot3Fz23-Ny^Th_pCpcG#Wlw7c1553t7`Vy}IRefA_T*^k+8dwDrzIS|U_wNN3ihe|jUs^D;_k|Uvu zc_UQC(a`re7MjfQU>vBEoG<+ljIYK$>y23xf5pknJ+~o~%UE!N`bA^0@H^q(VCE^|xH&;M=yu~s4>C9RY z|0ZId(Dvk4{+)bb?(z@O3WT`F+q^?uxVxMXt-nzBcvp(g680`9MJp8Y9`A`ZK=`}7 zFIth1j_?5=GEn+p4F43jSh`^-r^NMyy~jr!%ZS}7B_E4eBK$o*k;FmL1up**ZLsu! z$G=58TROqzKcWp0?%B61la5I6sko)m11>${mI?8!TQ0qj;4^WD3VoOVid!zIvu=fS zL4sMQ#Xd*4yYz}(A=Ew2i1rO(@5*qmVVDpfrIbX&g>N=8!Qdu4)bm3LcHhmvpITJ0)^vv%*uy6lDli%CVO7BEmnzh=y z757ZyS_>;Lp0=zHuz`(U2Y)^PX3^UD*;+EvUs;u`a;93j+vF7*AiC@(dofnABsSY6 z`tFJG?2tSVE8quq%9F*D_grZX9K(<$#f`n$30am?vNxf;Z4L1*CN_4n<)7Nh3di;$B z2O3iz>@2!kUpi)5HeLvO_L>iz9}@l38A6~Z`WtE9CE50Y#K?pR3x2D zDv?c98j&G&L2{@@F4bvIO*&JDZbGp;bt#}8eW*`A8Zwy145NuXhDYrQJZ4Yf341zE z*)t+EvuD!WUOeHI`m#0Jdt2&;MYRf~B;Eu+6$#{jj9f$9Kns>8gcPV=_9%3yVychnu;)o~2f<#|t6CZaPK zrn4BXn=nE*=L4O?NZp1HbsnR1J|F2GjMjY^qlYk7k6@f0$$0%SpXe!ks;A>c^b98G zVkYWUe5N-sNpIx~y_?DU5MSz3d@FFi(&zYEUty}TnP%ddZW1UmseEUuFw4|ro`9Qe z>M+MNX1-}fv3ZsSracQy9;GIqC8m(&0(Gegv&;-)g&D<4GoDq(BeKR!X04gYI=Rm4 z%_26M6>K&e*kZP^)$C!LIl^{xmL29YJIxLDm^W2bC+tJ~#BO{7+u>(&Bg6^Ym|aGwhu9;wUpPDLm1|W- zsK#7Jc!$_0ZoCk7*e|XlJY#NxkPdM`+<>rkI4Ev{fOR>VG;p}iqv~oh(6AX-JC?s8GIO2XdZl4zB6aYV$+B32Rp4!?<5RcOcFDJb_K#1(Nf zguKJ=;s%9t%*~V=5aJJUs|j<5tKwz~;h0-P*oU|#ZgrvUa9!LQg4*SVXf*}6!=IwH zswJH3a8uISLN%7@=n%a>V3T~A+~O}8v=x07xGkAYrZ0)VW&A4skr~m9$G!I}oG%lU c-(8syL2qt)wl^w0qeQ3MmY+K^L2T~+3-rC8(f|Me diff --git a/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeFeatures.class b/src/out/production/main/com/zipcodewilmington/scientificcalculator/CubeFeatures.class index 34153da72a9bb5b42886b002876a036f89f399df..61e9976f17bc490d2a696ded0ff106e4952f8a92 100644 GIT binary patch delta 17 YcmaFH{ET_SZbnvi22KW!$p;wK05o<4)&Kwi delta 17 YcmaFH{ET_SZbnu%22KX{$p;wK05oU>)Bpeg