From f46e8aa73ecbb24f2a2d6af4472e1951438b8bbb Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Fri, 7 Feb 2020 18:37:34 -0500 Subject: [PATCH 01/53] Another test --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8402302c..332adf26 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # ScientificCalculator (maven) ZCW - +## James ## Description In this project your team will build a small app to function as a calculator. This app will be built in Java, and will use the topics and techniques discussed during the week. From 38d58aac8bc7e179f28dbb96feed6f29930c88f2 Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Fri, 7 Feb 2020 18:56:12 -0500 Subject: [PATCH 02/53] Branches added --- .../zipcodewilmington/scientificcalculator/MainApplication.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f421325..b4a01666 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -2,6 +2,7 @@ /** * Created by leon on 2/9/18. + * James, Sandy and Zanetta version */ public class MainApplication { public static void main(String[] args) { From 97fdac838597a5bd39036de8de144f7c9667b195 Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Fri, 7 Feb 2020 19:01:10 -0500 Subject: [PATCH 03/53] Branches added --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 332adf26..9e3b8a06 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # ScientificCalculator (maven) ZCW -## James +## James Wilkinson ## Description In this project your team will build a small app to function as a calculator. This app will be built in Java, and will use the topics and techniques discussed during the week. From 20c420abbc0ac2c0bbd728759fd510ac7728267a Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Fri, 7 Feb 2020 19:05:32 -0500 Subject: [PATCH 04/53] Attempted to add branches? --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 9e3b8a06..332adf26 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # ScientificCalculator (maven) ZCW -## James Wilkinson +## James ## Description In this project your team will build a small app to function as a calculator. This app will be built in Java, and will use the topics and techniques discussed during the week. From 1a99ecbd37916d3277d7d5d4826f9d405b655218 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Fri, 7 Feb 2020 19:09:52 -0500 Subject: [PATCH 05/53] tracking adding to sandy branch --- seed | 1 + 1 file changed, 1 insertion(+) create mode 100644 seed diff --git a/seed b/seed new file mode 100644 index 00000000..f88aa5a7 --- /dev/null +++ b/seed @@ -0,0 +1 @@ +test & delete From 449656c1880fefcd4478c4db11d125e55f3bdef0 Mon Sep 17 00:00:00 2001 From: snmangalam2708 <60610814+snmangalam2708@users.noreply.github.com> Date: Fri, 7 Feb 2020 19:11:53 -0500 Subject: [PATCH 06/53] Delete seed --- seed | 1 - 1 file changed, 1 deletion(-) delete mode 100644 seed diff --git a/seed b/seed deleted file mode 100644 index f88aa5a7..00000000 --- a/seed +++ /dev/null @@ -1 +0,0 @@ -test & delete From 6d30b310df189ec43b43187e4a2e22a9562adf0f Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Fri, 7 Feb 2020 19:38:25 -0500 Subject: [PATCH 07/53] Silly test --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 332adf26..40ce4afe 100644 --- a/README.md +++ b/README.md @@ -63,7 +63,7 @@ Each operation should automatically update the display - Ln (natural logarithm) - ex (inverse natural logarithm) - Factorial function - +// ### Custom Features From ebc66144c85339ffa64bd5448235effd2fe8fd18 Mon Sep 17 00:00:00 2001 From: snmangalam2708 <60610814+snmangalam2708@users.noreply.github.com> Date: Fri, 7 Feb 2020 20:05:05 -0500 Subject: [PATCH 08/53] Create seed --- seed | 1 + 1 file changed, 1 insertion(+) create mode 100644 seed diff --git a/seed b/seed new file mode 100644 index 00000000..f88aa5a7 --- /dev/null +++ b/seed @@ -0,0 +1 @@ +test & delete From c3351e954d588b8c2bb9e41d5f223a91c289e249 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Fri, 7 Feb 2020 20:07:17 -0500 Subject: [PATCH 09/53] sandy --- seed2 | 1 + 1 file changed, 1 insertion(+) create mode 100644 seed2 diff --git a/seed2 b/seed2 new file mode 100644 index 00000000..f88aa5a7 --- /dev/null +++ b/seed2 @@ -0,0 +1 @@ +test & delete From 5c6a06ab1dbefd1074f327470f5cde4ce761ccdc Mon Sep 17 00:00:00 2001 From: snmangalam2708 <60610814+snmangalam2708@users.noreply.github.com> Date: Fri, 7 Feb 2020 20:15:27 -0500 Subject: [PATCH 10/53] Delete seed --- seed | 1 - 1 file changed, 1 deletion(-) delete mode 100644 seed diff --git a/seed b/seed deleted file mode 100644 index f88aa5a7..00000000 --- a/seed +++ /dev/null @@ -1 +0,0 @@ -test & delete From 277e7744138d7b8bf29ba9ab4e03b8f6d4d52762 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Fri, 7 Feb 2020 20:15:45 -0500 Subject: [PATCH 11/53] remove sed2 --- seed | 1 - seed2 | 1 - 2 files changed, 2 deletions(-) delete mode 100644 seed delete mode 100644 seed2 diff --git a/seed b/seed deleted file mode 100644 index f88aa5a7..00000000 --- a/seed +++ /dev/null @@ -1 +0,0 @@ -test & delete diff --git a/seed2 b/seed2 deleted file mode 100644 index f88aa5a7..00000000 --- a/seed2 +++ /dev/null @@ -1 +0,0 @@ -test & delete From 5791ccceae19cb57e6cf89a9911371cc847eb100 Mon Sep 17 00:00:00 2001 From: snmangalam2708 <60610814+snmangalam2708@users.noreply.github.com> Date: Fri, 7 Feb 2020 20:16:16 -0500 Subject: [PATCH 12/53] Delete seed2 --- seed2 | 1 - 1 file changed, 1 deletion(-) delete mode 100644 seed2 diff --git a/seed2 b/seed2 deleted file mode 100644 index f88aa5a7..00000000 --- a/seed2 +++ /dev/null @@ -1 +0,0 @@ -test & delete From 0976179e70058594f98609a080568c6940c71987 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Fri, 7 Feb 2020 20:16:54 -0500 Subject: [PATCH 13/53] added seed3 --- seed3 | 1 + 1 file changed, 1 insertion(+) create mode 100644 seed3 diff --git a/seed3 b/seed3 new file mode 100644 index 00000000..8a39ce77 --- /dev/null +++ b/seed3 @@ -0,0 +1 @@ +hjghgk From 53845bf7ee4325731ce1d1e40c903673df8b88da Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Fri, 7 Feb 2020 20:29:57 -0500 Subject: [PATCH 14/53] check --- seed3 | 1 - 1 file changed, 1 deletion(-) delete mode 100644 seed3 diff --git a/seed3 b/seed3 deleted file mode 100644 index 8a39ce77..00000000 --- a/seed3 +++ /dev/null @@ -1 +0,0 @@ -hjghgk From 9448eb0a22938e895c078aa2a9b8e75fbfba2598 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Fri, 7 Feb 2020 20:31:20 -0500 Subject: [PATCH 15/53] gr8ness --- gr8 | 1 + 1 file changed, 1 insertion(+) create mode 100644 gr8 diff --git a/gr8 b/gr8 new file mode 100644 index 00000000..6daf2af3 --- /dev/null +++ b/gr8 @@ -0,0 +1 @@ +gr8 From 9a2edeb8d352fc19010221ac3cdccc3ee57515b4 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Fri, 7 Feb 2020 20:32:08 -0500 Subject: [PATCH 16/53] remove gr8 --- gr8 | 1 - 1 file changed, 1 deletion(-) delete mode 100644 gr8 diff --git a/gr8 b/gr8 deleted file mode 100644 index 6daf2af3..00000000 --- a/gr8 +++ /dev/null @@ -1 +0,0 @@ -gr8 From 3ffeeedbc47a2d80864eb31d9dcfb483607642c3 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Sat, 8 Feb 2020 11:06:28 -0500 Subject: [PATCH 17/53] test --- Hello.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Hello.txt diff --git a/Hello.txt b/Hello.txt new file mode 100644 index 00000000..e69de29b From 3115773027a1a10cfc39a646c5af0d5ce452a75e Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Sat, 8 Feb 2020 11:14:46 -0500 Subject: [PATCH 18/53] adding hello --- Hello.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Hello.txt diff --git a/Hello.txt b/Hello.txt new file mode 100644 index 00000000..e69de29b From b662544b449179f28d178787d609bb23fbd58e22 Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sat, 8 Feb 2020 11:15:58 -0500 Subject: [PATCH 19/53] Small comment edit --- .../zipcodewilmington/scientificcalculator/MainApplication.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f421325..3c419d8d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -2,6 +2,7 @@ /** * Created by leon on 2/9/18. + * James Wilkinson */ public class MainApplication { public static void main(String[] args) { From 877626e8c8f0129b5a15cff0e31f453472bb22c4 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Sat, 8 Feb 2020 11:19:55 -0500 Subject: [PATCH 20/53] . --- blah.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 blah.txt diff --git a/blah.txt b/blah.txt new file mode 100644 index 00000000..e69de29b From aebe5d36a4308e1c5c79f1eeece1a63230acc5fb Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sat, 8 Feb 2020 12:59:13 -0500 Subject: [PATCH 21/53] Memory added --- .../scientificcalculator/MainApplication.java | 1 - .../scientificcalculator/Memory.java | 21 +++++++++++++++++++ 2 files changed, 21 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/Memory.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 3c419d8d..5f421325 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -2,7 +2,6 @@ /** * Created by leon on 2/9/18. - * James Wilkinson */ public class MainApplication { public static void main(String[] args) { diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Memory.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Memory.java new file mode 100644 index 00000000..d30fb5a2 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Memory.java @@ -0,0 +1,21 @@ +package com.zipcodewilmington.scientificcalculator; + +public class Memory { + private Double value; + + public Memory() { + value = 0.0; + } + + public Double getMemory() { + return value; + } + + public void setMemory(Double input) { + this.value = input; + } + + public void resetMemory() { + this.value = 0.0; + } +} \ No newline at end of file From 33dfc4e03d0930ac02fe81b6a2b8b8ce3fca14a2 Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sat, 8 Feb 2020 16:08:02 -0500 Subject: [PATCH 22/53] Memory working and tested --- pom.xml | 8 ++ .../scientificcalculator/Console.java | 14 ++- .../scientificcalculator/Display.java | 32 ++++++ .../scientificcalculator/MainApplication.java | 2 +- .../scientificcalculator/Memory.java | 12 +-- .../scientific_calculator/TestMemory.java | 98 +++++++++++++++++++ 6 files changed, 156 insertions(+), 10 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/Display.java create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/TestMemory.java diff --git a/pom.xml b/pom.xml index e7cb4f6b..d8cd763e 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,14 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + + junit + junit + 4.12 + test + + \ 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 83f0e97f..f874f1e3 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -23,10 +23,18 @@ public static String getStringInput(String prompt) { } public static Integer getIntegerInput(String prompt) { - return null; + Scanner scanner = new Scanner(System.in); + println(prompt); + String userInput; + userInput = scanner.nextLine(); + return Integer.parseInt(userInput); } public static Double getDoubleInput(String prompt) { - return null; + Scanner scanner = new Scanner(System.in); + println(prompt); + String userInput; + userInput = scanner.nextLine(); + return Double.parseDouble(userInput); } -} +} \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java new file mode 100644 index 00000000..7b14faa7 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -0,0 +1,32 @@ +/* + +package com.zipcodewilmington.scientificcalculator; + +public class Display { + Double currentValue; + String currentOperation; + Boolean error; + enum Modes { BINARY, OCTAL, DEC, HEX } + Modes mode; + + public void Display() { + if(error) { + // Print "ERR" + } else { + //if(mode) + } + } + + public void update() { + + } + + public void clear() { + + } + + public void invSign() { + return currentValue * -1; + } +} +*/ \ 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 5f421325..47a03684 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -14,4 +14,4 @@ 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); } -} +} \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Memory.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Memory.java index d30fb5a2..f8bfb308 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Memory.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Memory.java @@ -1,21 +1,21 @@ package com.zipcodewilmington.scientificcalculator; public class Memory { - private Double value; + private static Double value; public Memory() { value = 0.0; } - public Double getMemory() { + public static Double getMemory() { return value; } - public void setMemory(Double input) { - this.value = input; + public static void setMemory(Double input) { + value = input; } - public void resetMemory() { - this.value = 0.0; + public static void resetMemory() { + value = 0.0; } } \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMemory.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMemory.java new file mode 100644 index 00000000..4df437b0 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMemory.java @@ -0,0 +1,98 @@ +package com.zipcodewilmington.scientific_calculator; + +import com.zipcodewilmington.scientificcalculator.Memory; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; + +public class TestMemory { + @Test + public void TestSetMemoryToOneHundred() + { + Double expected = 100.00; + Memory TestMemory = new Memory(); + TestMemory.setMemory(100.00); + Double actual = TestMemory.getMemory(); + + assertEquals(expected, actual); + } + + @Test + public void TestSetMemoryToNegativeFive() + { + Double expected = -5.0; + Memory TestMemory = new Memory(); + TestMemory.setMemory(-5.0); + Double actual = TestMemory.getMemory(); + + assertEquals(expected, actual); + } + + @Test + public void TestSetMemoryToPointOne() + { + Double expected = 0.1; + Memory TestMemory = new Memory(); + TestMemory.setMemory(0.1); + Double actual = TestMemory.getMemory(); + + assertEquals(expected, actual); + } + + @Test + public void TestResetMemory() + { + Double expected = 0.0; + Memory TestMemory = new Memory(); + TestMemory.setMemory(-5.0); + TestMemory.resetMemory(); + Double actual = TestMemory.getMemory(); + + assertEquals(expected, actual); + } + + @Test + public void TestMemoryNaN() + { + Double expected = Double.NaN; + Memory TestMemory = new Memory(); + Double actual = TestMemory.getMemory(); + + assertNotEquals(expected, actual); + } + + @Test + public void TestResetMemoryNaN() + { + Double expected = Double.NaN; + Memory TestMemory = new Memory(); + TestMemory.setMemory(7.0); + TestMemory.resetMemory(); + Double actual = TestMemory.getMemory(); + + assertNotEquals(expected, actual); + } + + @Test + public void TestMemoryNull() + { + Double expected = null; + Memory TestMemory = new Memory(); + Double actual = TestMemory.getMemory(); + + assertNotEquals(expected, actual); + } + + @Test + public void TestResetMemoryNull() + { + Double expected = null; + Memory TestMemory = new Memory(); + TestMemory.setMemory(1979.0000); + TestMemory.resetMemory(); + Double actual = TestMemory.getMemory(); + + assertNotEquals(expected, actual); + } +} From 3f429276a2a8398f9632255850fce358d39df27d Mon Sep 17 00:00:00 2001 From: Zanetta Norris Date: Sat, 8 Feb 2020 16:43:28 -0500 Subject: [PATCH 23/53] Testing push --- .../com/zipcodewilmington/scientificcalculator/BasicMath.java | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java new file mode 100644 index 00000000..fd2fd6d9 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java @@ -0,0 +1,4 @@ +package com.zipcodewilmington.scientificcalculator; + +public class BasicMath { +} From 258dba84a431c15ff092a43621be0715031a149b Mon Sep 17 00:00:00 2001 From: Zanetta Norris Date: Sat, 8 Feb 2020 18:00:02 -0500 Subject: [PATCH 24/53] Building basic math methods and tests --- .../scientificcalculator/BasicMath.java | 26 ++++++++++++++++- .../scientific_calculator/TestBasicMath.java | 29 +++++++++++++++++++ 2 files changed, 54 insertions(+), 1 deletion(-) create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java index fd2fd6d9..121d2184 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java @@ -1,4 +1,28 @@ package com.zipcodewilmington.scientificcalculator; public class BasicMath { -} + // two operator methods + public static Double addition (Double numberOne, Double numberTwo) { + return (numberOne + numberTwo); + } + public static Double subtraction (Double numberOne, Double numberTwo) { + return numberOne - numberTwo; + } + public static Double multiplication (Double numberOne, Double numberTwo) { + return numberOne * numberTwo; + } + public static Double division (Double numberOne, Double numberTwo) { + return numberOne / numberTwo; + } + // one operator methods + + public static Double square (Double numberOne) { + return numberOne * numberOne; + } + public static Double squareroot (Double numberOne){ + return (Math.sqrt(numberOne)); + } + } + + + diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java new file mode 100644 index 00000000..99691a74 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java @@ -0,0 +1,29 @@ +package com.zipcodewilmington.scientific_calculator; + +import com.zipcodewilmington.scientificcalculator.BasicMath; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class TestBasicMath { + + @Test + public void TestAdditionThirtyPlusFifteen() + { + BasicMath additionTest = new BasicMath(); + Double actual; + Double expected = 45.0; + actual = additionTest.addition(30.0,15.0); + assertEquals(expected, actual); + } + + @Test + public void TestSubtractionThirtyFifteen() + { + BasicMath subtractionTest = new BasicMath(); + Double actual; + Double expected = 15.0; + actual = subtractionTest.subtraction(30.0,15.0); + assertEquals(expected, actual); + } +} From 369df63965133610ca158882f17e9a20570ce2bc Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sat, 8 Feb 2020 18:03:35 -0500 Subject: [PATCH 25/53] Please don't kill me --- .../scientificcalculator/Display.java | 57 +++++++++++++------ .../scientificcalculator/DisplayTest.java | 23 ++++++++ 2 files changed, 62 insertions(+), 18 deletions(-) create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 7b14faa7..391eb78a 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -1,32 +1,53 @@ -/* - package com.zipcodewilmington.scientificcalculator; public class Display { - Double currentValue; - String currentOperation; - Boolean error; - enum Modes { BINARY, OCTAL, DEC, HEX } - Modes mode; + private Double currentValue; + private String currentOperation; + private Boolean error; + private enum Modes { BINARY, OCTAL, DEC, HEX } + private Modes mode; + + public Display() + { + currentValue = 0.0; + mode = Modes.DEC; + error = false; + // currentOperation + } + + public void update() + { + String output; - public void Display() { if(error) { - // Print "ERR" - } else { - //if(mode) + output = "ERR"; } - } + else if(mode == Modes.BINARY) + { - public void update() { + } + else if(mode == Modes.OCTAL) + { + } + else if(mode == Modes.DEC) + { + output = Double.toString(currentValue); + } + else if(mode == Modes.HEX) + { + + } + +// Console.println(output); } public void clear() { - + currentValue = 0.0; + update(); } - public void invSign() { - return currentValue * -1; + public Double invSign() { + return currentValue * -1.0; } -} -*/ \ No newline at end of file +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java new file mode 100644 index 00000000..a808d46e --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java @@ -0,0 +1,23 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class DisplayTest { + + @Test + public void update() { + String expected = "0"; + Display TestDisplay = new Display(); + // String actual = String.toString(TestDisplay.update()); + } + + @Test + public void clear() { + } + + @Test + public void invSign() { + } +} \ No newline at end of file From 420bd2a892442fbc171dded6b619834a84db6202 Mon Sep 17 00:00:00 2001 From: Zanetta Norris Date: Sat, 8 Feb 2020 19:04:27 -0500 Subject: [PATCH 26/53] Added eight new basic math methods, and seven additional test cases. --- .../scientificcalculator/BasicMath.java | 9 ++ .../scientific_calculator/TestBasicMath.java | 87 ++++++++++++++++--- 2 files changed, 86 insertions(+), 10 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java index 121d2184..a955c769 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java @@ -13,6 +13,9 @@ public static Double multiplication (Double numberOne, Double numberTwo) { } public static Double division (Double numberOne, Double numberTwo) { return numberOne / numberTwo; + } + public static Double exponent (Double numberOne, Double numberTwo){ + return Math.pow(numberOne, numberTwo); } // one operator methods @@ -22,7 +25,13 @@ public static Double square (Double numberOne) { public static Double squareroot (Double numberOne){ return (Math.sqrt(numberOne)); } + public static Double inverse(Double numberOne){ + return 1/numberOne; } + } + + + diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java index 99691a74..d42a6891 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java @@ -6,24 +6,91 @@ import static org.junit.Assert.assertEquals; public class TestBasicMath { - +// Addition test cases @Test - public void TestAdditionThirtyPlusFifteen() + public void TestAdditionWhole() { - BasicMath additionTest = new BasicMath(); - Double actual; - Double expected = 45.0; - actual = additionTest.addition(30.0,15.0); - assertEquals(expected, actual); + BasicMath additionTest = new BasicMath(); + Double actual; + Double expected = 45.0; + actual = additionTest.addition(30.0,15.0); + assertEquals(expected, actual); + } + @Test + public void TestAdditionNegative() + { + BasicMath additionTest = new BasicMath(); + Double actual; + Double expected = 3.0; + actual = additionTest.addition(8.0,-5.0); + assertEquals(expected, actual); } - + @Test + public void TestAdditionDecimal() + { + BasicMath additionTest = new BasicMath(); + Double actual; + Double expected = 57.4; + actual = additionTest.addition(55.0,2.4); + assertEquals(expected, actual); + } +// Subtraction test cases @Test public void TestSubtractionThirtyFifteen() { - BasicMath subtractionTest = new BasicMath(); + BasicMath subtractionTest = new BasicMath(); + Double actual; + Double expected = 15.0; + actual = subtractionTest.subtraction(30.0,15.0); + assertEquals(expected, actual); + } + // Multiplication test cases + @Test + public void TestMultiplicationThreeFive() + { + BasicMath multiplicationTest = new BasicMath(); Double actual; Double expected = 15.0; - actual = subtractionTest.subtraction(30.0,15.0); + actual = multiplicationTest.multiplication(3.0,5.0); + assertEquals(expected, actual); + } + // Division Test Cases + @Test + public void TestDivisionSixTwo() + { + BasicMath divisionTest = new BasicMath(); + Double actual; + Double expected = 3.0; + actual = divisionTest.division(6.0,2.0); + assertEquals(expected, actual); + } + @Test + public void TestExponentSixTwo() + { + BasicMath exponentTest = new BasicMath(); + Double actual; + Double expected = 36.0; + actual = exponentTest.exponent(6.0,2.0); + assertEquals(expected, actual); + } + //Square Test Cases + @Test + public void TestsquareFour() + { + BasicMath squareTest = new BasicMath(); + Double actual; + Double expected = 16.0; + actual = squareTest.square(4.0); + assertEquals(expected, actual); + } + @Test + public void TestSquareRootTwentyFive() + { + BasicMath squarerootTest = new BasicMath(); + Double actual; + Double expected = 5.0; + actual = squarerootTest.squareroot(25.0); assertEquals(expected, actual); } } + From a9c39a1fd0333ae6f0801eff8cd4cde15154cc4f Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sat, 8 Feb 2020 19:13:02 -0500 Subject: [PATCH 27/53] About to pull dev --- .../scientificcalculator/Display.java | 51 ++++++++++++---- .../scientificcalculator/DisplayTest.java | 58 +++++++++++++++++-- 2 files changed, 95 insertions(+), 14 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 391eb78a..afc55e29 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -15,39 +15,70 @@ public Display() // currentOperation } - public void update() + public void setDisplay(Double inputValue) { - String output; + currentValue = inputValue; + } + + public Double getDisplay() + { + return currentValue; + } + + public String Update() + { + String output = ""; if(error) { output = "ERR"; } else if(mode == Modes.BINARY) { - + output = Integer.toBinaryString(currentValue.intValue()); } else if(mode == Modes.OCTAL) { - + output = Integer.toOctalString(currentValue.intValue()); } else if(mode == Modes.DEC) { - output = Double.toString(currentValue); + if(currentValue % 1 == 0) // No decimal + { + output = Integer.toString(currentValue.intValue()); + } + else + { + output = Double.toString(currentValue); + } } else if(mode == Modes.HEX) { - + output = Integer.toHexString(currentValue.intValue()); } -// Console.println(output); + Console.println("%s", output); + return output; } - public void clear() { + public void Clear() { currentValue = 0.0; - update(); + Update(); } - public Double invSign() { + public Double InvSign() + { return currentValue * -1.0; } + + public Double AbsoluteValue() + { + if(currentValue < 0) + { + return currentValue * -1; + } + else + { + return currentValue; + } + } } \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java index a808d46e..aeb18d89 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java @@ -7,17 +7,67 @@ public class DisplayTest { @Test - public void update() { + public void TestUpdateInitValue() + { String expected = "0"; Display TestDisplay = new Display(); - // String actual = String.toString(TestDisplay.update()); + String actual = TestDisplay.Update(); + + assertEquals(expected, actual); + } + + @Test + public void TestClear() { + Double expected = 0.0; + Display TestDisplay = new Display(); + Double actual; + TestDisplay.setDisplay(99.99999); + TestDisplay.Clear(); + actual = TestDisplay.getDisplay(); + + assertEquals(expected, actual); + } + + @Test + public void TestInvSign() { + Double expected = -47.6; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(47.6); + Double actual = TestDisplay.InvSign(); + + assertEquals(expected, actual); + } + + @Test + public void TestAbsoluteValueOfTen() + { + Double expected = 10.0; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(10.0); + Double actual = TestDisplay.AbsoluteValue(); + + assertEquals(expected, actual); } @Test - public void clear() { + public void TestAbsoluteValueOfNegFourtyFive() + { + Double expected = 45.0; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(-45.0); + Double actual = TestDisplay.AbsoluteValue(); + + assertEquals(expected, actual); } @Test - public void invSign() { + public void TestAbsoluteValueOfZero() + { + Double expected = 0.0; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(0.0); + Double actual = TestDisplay.AbsoluteValue(); + + assertEquals(expected, actual); } } \ No newline at end of file From 7b6c3bb808e4eded13efb519b47b857995ed9b8d Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sat, 8 Feb 2020 19:56:13 -0500 Subject: [PATCH 28/53] Done for the night --- .../scientificcalculator/Display.java | 20 +++++++---- .../scientificcalculator/DisplayTest.java | 36 +++++++++++++++---- 2 files changed, 44 insertions(+), 12 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index afc55e29..ac823464 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -4,7 +4,7 @@ public class Display { private Double currentValue; private String currentOperation; private Boolean error; - private enum Modes { BINARY, OCTAL, DEC, HEX } + public enum Modes { BINARY, OCTAL, DEC, HEX } private Modes mode; public Display() @@ -25,7 +25,7 @@ public Double getDisplay() return currentValue; } - public String Update() + public String update() { String output = ""; @@ -35,10 +35,12 @@ public String Update() else if(mode == Modes.BINARY) { output = Integer.toBinaryString(currentValue.intValue()); + currentValue = Double.parseDouble(output); } else if(mode == Modes.OCTAL) { output = Integer.toOctalString(currentValue.intValue()); + currentValue = Double.parseDouble(output); } else if(mode == Modes.DEC) { @@ -54,23 +56,29 @@ else if(mode == Modes.DEC) else if(mode == Modes.HEX) { output = Integer.toHexString(currentValue.intValue()); + currentValue = Double.parseDouble(output); } Console.println("%s", output); return output; } - public void Clear() { + public void setMode(Modes newMode) + { + mode = newMode; + } + + public void clear() { currentValue = 0.0; - Update(); + update(); } - public Double InvSign() + public Double invSign() { return currentValue * -1.0; } - public Double AbsoluteValue() + public Double absoluteValue() { if(currentValue < 0) { diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java index aeb18d89..88ed68a5 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java @@ -11,7 +11,31 @@ public void TestUpdateInitValue() { String expected = "0"; Display TestDisplay = new Display(); - String actual = TestDisplay.Update(); + String actual = TestDisplay.update(); + + assertEquals(expected, actual); + } + + @Test + public void TestUpdateBinaryEight() + { + String expected = "1000"; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(8.0); + TestDisplay.setMode(Display.Modes.BINARY); + String actual = TestDisplay.update(); + + assertEquals(expected, actual); + } + + @Test + public void TestUpdateBinaryTwentyPointFive() + { + String expected = "10100"; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(20.5); + TestDisplay.setMode(Display.Modes.BINARY); + String actual = TestDisplay.update(); assertEquals(expected, actual); } @@ -22,7 +46,7 @@ public void TestClear() { Display TestDisplay = new Display(); Double actual; TestDisplay.setDisplay(99.99999); - TestDisplay.Clear(); + TestDisplay.clear(); actual = TestDisplay.getDisplay(); assertEquals(expected, actual); @@ -33,7 +57,7 @@ public void TestInvSign() { Double expected = -47.6; Display TestDisplay = new Display(); TestDisplay.setDisplay(47.6); - Double actual = TestDisplay.InvSign(); + Double actual = TestDisplay.invSign(); assertEquals(expected, actual); } @@ -44,7 +68,7 @@ public void TestAbsoluteValueOfTen() Double expected = 10.0; Display TestDisplay = new Display(); TestDisplay.setDisplay(10.0); - Double actual = TestDisplay.AbsoluteValue(); + Double actual = TestDisplay.absoluteValue(); assertEquals(expected, actual); } @@ -55,7 +79,7 @@ public void TestAbsoluteValueOfNegFourtyFive() Double expected = 45.0; Display TestDisplay = new Display(); TestDisplay.setDisplay(-45.0); - Double actual = TestDisplay.AbsoluteValue(); + Double actual = TestDisplay.absoluteValue(); assertEquals(expected, actual); } @@ -66,7 +90,7 @@ public void TestAbsoluteValueOfZero() Double expected = 0.0; Display TestDisplay = new Display(); TestDisplay.setDisplay(0.0); - Double actual = TestDisplay.AbsoluteValue(); + Double actual = TestDisplay.absoluteValue(); assertEquals(expected, actual); } From dd97db4076ae72005fd0d35f48f7fd3e5b44d2ee Mon Sep 17 00:00:00 2001 From: Zanetta Norris Date: Sat, 8 Feb 2020 20:01:31 -0500 Subject: [PATCH 29/53] added more test cases for basic math --- .../scientific_calculator/TestBasicMath.java | 61 ++++++++++++++++++- 1 file changed, 59 insertions(+), 2 deletions(-) diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java index d42a6891..a814b6f3 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java @@ -44,9 +44,38 @@ public void TestSubtractionThirtyFifteen() actual = subtractionTest.subtraction(30.0,15.0); assertEquals(expected, actual); } + @Test + public void TestSubtractionNegatives() + { + BasicMath subtractionTest = new BasicMath(); + Double actual; + Double expected = 25.0; + actual = subtractionTest.subtraction(17.0,-8.0); + assertEquals(expected, actual); + } + + @Test + public void TestSubtractionDecimal() + { + BasicMath subtractionTest = new BasicMath(); + Double actual; + Double expected = 5.9; + actual = subtractionTest.subtraction(12.4,6.5); + assertEquals(expected, actual); + } + + @Test + public void TestSubtractionGreater() + { + BasicMath subtractionTest = new BasicMath(); + Double actual; + Double expected = -11.8; + actual = subtractionTest.subtraction(4.7,16.5); + assertEquals(expected, actual); + } // Multiplication test cases @Test - public void TestMultiplicationThreeFive() + public void TestMultiplicationWholes() { BasicMath multiplicationTest = new BasicMath(); Double actual; @@ -54,9 +83,19 @@ public void TestMultiplicationThreeFive() actual = multiplicationTest.multiplication(3.0,5.0); assertEquals(expected, actual); } + @Test + public void TestMultiplicationDecimals() + { + BasicMath multiplicationTest = new BasicMath(); + Double actual; + Double expected = 18.480000000000004; + // fix this rounding error + actual = multiplicationTest.multiplication(8.4,2.2); + assertEquals(expected, actual); + } // Division Test Cases @Test - public void TestDivisionSixTwo() + public void TestDivisionWholes() { BasicMath divisionTest = new BasicMath(); Double actual; @@ -65,6 +104,15 @@ public void TestDivisionSixTwo() assertEquals(expected, actual); } @Test + public void TestDivisionDecimals() + { + BasicMath divisionTest = new BasicMath(); + Double actual; + Double expected = 6.2; + actual = divisionTest.division(12.4,2.0); + assertEquals(expected, actual); + } + @Test public void TestExponentSixTwo() { BasicMath exponentTest = new BasicMath(); @@ -92,5 +140,14 @@ public void TestSquareRootTwentyFive() actual = squarerootTest.squareroot(25.0); assertEquals(expected, actual); } + @Test + public void TestSquareRootFour() + { + BasicMath squarerootTest = new BasicMath(); + Double actual; + Double expected = 2.0; + actual = squarerootTest.squareroot(4.0); + assertEquals(expected, actual); + } } From 20412ead5f4183e9d3c8b2bb1b006ae7170dca0a Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 05:16:48 -0500 Subject: [PATCH 30/53] BoxMaker untested --- .../scientificcalculator/BoxMaker.java | 55 +++++++++++++++++++ .../scientificcalculator/Display.java | 8 ++- .../scientificcalculator/MainApplication.java | 1 + 3 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java new file mode 100644 index 00000000..f6cd44a5 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java @@ -0,0 +1,55 @@ +package com.zipcodewilmington.scientificcalculator; + +public class BoxMaker { + private int width; + + public BoxMaker() { + width = 30; + } + + public BoxMaker(int initialWidth) + { + width = initialWidth; + } + + public int getWidth() { + return width; + } + + public void setWidth(int newWidth) + { + width = newWidth; + } + + public String draw(String ... input) { + StringBuilder output = new StringBuilder(); + + output.append("╔"); + for(int i = 0; i < width - 2; i++) { + output.append("═"); + } + output.append("╗\n"); + + for (String element : input) + { + String line = ""; + StringBuilder lineFormat = new StringBuilder(); + lineFormat.append("%"); + lineFormat.append(width - 2); + lineFormat.append("s"); + + line = String.format(lineFormat.toString(), element); + output.append("║"); + output.append(line); + output.append("║\n"); + } + + output.append("╚"); + for(int i = 0; i < width - 2; i++) { + output.append("═"); + } + output.append("╝\n"); + + return output.toString(); + } +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index ac823464..57187276 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -1,6 +1,10 @@ package com.zipcodewilmington.scientificcalculator; +import javax.swing.*; + public class Display { + private int displayWidth; + private BoxMaker displayBox; private Double currentValue; private String currentOperation; private Boolean error; @@ -12,6 +16,8 @@ public Display() currentValue = 0.0; mode = Modes.DEC; error = false; + displayWidth = 50; + displayBox = new BoxMaker(); // currentOperation } @@ -59,7 +65,7 @@ else if(mode == Modes.HEX) currentValue = Double.parseDouble(output); } - Console.println("%s", output); + Console.println("%s", displayBox.draw(output)); return output; } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 0adeabf8..021ddea1 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -6,6 +6,7 @@ */ public class MainApplication { public static void main(String[] args) { + BoxMaker display = new BoxMaker(100); Console.println("Welcome to my calculator!"); String s = Console.getStringInput("Enter a string"); Integer i = Console.getIntegerInput("Enter an integer"); From 64133035b575cef1d5336be32d9d8e51a1ecadb6 Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 06:10:16 -0500 Subject: [PATCH 31/53] Changed display, broke tests --- .../scientificcalculator/Display.java | 63 ++++++++++++++----- .../scientificcalculator/DisplayTest.java | 15 ++++- 2 files changed, 60 insertions(+), 18 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 57187276..e72875f6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -7,18 +7,18 @@ public class Display { private BoxMaker displayBox; private Double currentValue; private String currentOperation; - private Boolean error; public enum Modes { BINARY, OCTAL, DEC, HEX } private Modes mode; + private Boolean isRadians; public Display() { currentValue = 0.0; mode = Modes.DEC; - error = false; displayWidth = 50; - displayBox = new BoxMaker(); - // currentOperation + displayBox = new BoxMaker(displayWidth); + isRadians = false; + currentOperation = ""; } public void setDisplay(Double inputValue) @@ -31,41 +31,70 @@ public Double getDisplay() return currentValue; } + // Future implimentation, running out of time to format correctly with DEG/RAD and + // BINARY/OCTAL/HEX left-justification on display + public void setDisplayWidth(int newWidth) + { + displayWidth = newWidth; + } + public String update() { - String output = ""; + String output; + String radianLine = ""; + String valueLine = ""; + String baseLine = ""; - if(error) { - output = "ERR"; + if(currentValue == Double.NaN || currentValue == null) + { + radianLine = String.format("%-46s", "ERR"); + valueLine = "ERR "; + baseLine = String.format("%-46s","ERR"); + output = displayBox.draw(radianLine, valueLine, baseLine); + return output; } - else if(mode == Modes.BINARY) + + if(isRadians == true) + { + radianLine = String.format("%-46s", "RAD"); + } + else + { + radianLine = " "; + } + + if(mode == Modes.BINARY) { - output = Integer.toBinaryString(currentValue.intValue()); - currentValue = Double.parseDouble(output); + baseLine = String.format("%-46s", "BIN"); + valueLine = Integer.toBinaryString(currentValue.intValue()) + " "; + currentValue = Double.parseDouble(valueLine); } else if(mode == Modes.OCTAL) { - output = Integer.toOctalString(currentValue.intValue()); - currentValue = Double.parseDouble(output); + baseLine = String.format("%-46s", "OCTAL"); + valueLine = Integer.toOctalString(currentValue.intValue()) + " "; + currentValue = Double.parseDouble(valueLine); } else if(mode == Modes.DEC) { if(currentValue % 1 == 0) // No decimal { - output = Integer.toString(currentValue.intValue()); + valueLine = Integer.toString(currentValue.intValue()) + " "; } else { - output = Double.toString(currentValue); + valueLine = Double.toString(currentValue) + " "; } } else if(mode == Modes.HEX) { - output = Integer.toHexString(currentValue.intValue()); - currentValue = Double.parseDouble(output); + baseLine = String.format("%-46s", "HEX"); + valueLine = Integer.toHexString(currentValue.intValue()) + " "; + currentValue = Double.parseDouble(valueLine); } - Console.println("%s", displayBox.draw(output)); + output = displayBox.draw(radianLine, valueLine, baseLine); + Console.println("%s", output); return output; } diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java index 88ed68a5..e53b99ba 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java @@ -5,11 +5,24 @@ import static org.junit.Assert.*; public class DisplayTest { +/* Goal format: +╔════════════════════════════════════════════════╗ +║ ║ +║ 10100 ║ +║ BIN ║ +╚════════════════════════════════════════════════╝ + + */ @Test public void TestUpdateInitValue() { - String expected = "0"; + String expected = + "╔════════════════════════════════════════════════╗\n" + + "║ ║\n" + + "║ 0 ║\n" + + "║ ║\n" + + "╚════════════════════════════════════════════════╝\n"; Display TestDisplay = new Display(); String actual = TestDisplay.update(); From a12ff3ea641cb0ceb00ba3b9dc04c81a1fb1c710 Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 06:46:33 -0500 Subject: [PATCH 32/53] Test cases for display --- .../scientificcalculator/Display.java | 41 ++++++++- .../scientificcalculator/MainApplication.java | 1 - .../scientificcalculator/DisplayTest.java | 91 ++++++++++++++++++- 3 files changed, 126 insertions(+), 7 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index e72875f6..36bc2498 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -6,10 +6,11 @@ public class Display { private int displayWidth; private BoxMaker displayBox; private Double currentValue; - private String currentOperation; +// private String currentOperation; Moving to input public enum Modes { BINARY, OCTAL, DEC, HEX } private Modes mode; private Boolean isRadians; + Boolean error; public Display() { @@ -18,12 +19,21 @@ public Display() displayWidth = 50; displayBox = new BoxMaker(displayWidth); isRadians = false; - currentOperation = ""; +// currentOperation = ""; + error = false; } public void setDisplay(Double inputValue) { - currentValue = inputValue; + if (inputValue == Double.NaN || + inputValue == Double.POSITIVE_INFINITY || + inputValue == Double.NEGATIVE_INFINITY) + { + error = true; + } + else { + currentValue = inputValue; + } } public Double getDisplay() @@ -45,7 +55,7 @@ public String update() String valueLine = ""; String baseLine = ""; - if(currentValue == Double.NaN || currentValue == null) + if(error) { radianLine = String.format("%-46s", "ERR"); valueLine = "ERR "; @@ -103,6 +113,29 @@ public void setMode(Modes newMode) mode = newMode; } + public void setMode() { + switch (mode) + { + case DEC: + setMode(Modes.BINARY); + break; + case BINARY: + setMode(Modes.OCTAL); + break; + case OCTAL: + setMode(Modes.HEX); + break; + case HEX: + setMode(Modes.DEC); + break; + } + } + + public Modes getMode() + { + return mode; + } + public void clear() { currentValue = 0.0; update(); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 021ddea1..0adeabf8 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -6,7 +6,6 @@ */ public class MainApplication { public static void main(String[] args) { - BoxMaker display = new BoxMaker(100); Console.println("Welcome to my calculator!"); String s = Console.getStringInput("Enter a string"); Integer i = Console.getIntegerInput("Enter an integer"); diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java index e53b99ba..3d4c4816 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java @@ -1,6 +1,7 @@ package com.zipcodewilmington.scientificcalculator; import org.junit.Test; +import org.junit.experimental.theories.suppliers.TestedOn; import static org.junit.Assert.*; @@ -32,7 +33,12 @@ public void TestUpdateInitValue() @Test public void TestUpdateBinaryEight() { - String expected = "1000"; + String expected = + "╔════════════════════════════════════════════════╗\n" + + "║ ║\n" + + "║ 1000 ║\n" + + "║ BIN ║\n" + + "╚════════════════════════════════════════════════╝\n"; Display TestDisplay = new Display(); TestDisplay.setDisplay(8.0); TestDisplay.setMode(Display.Modes.BINARY); @@ -44,7 +50,12 @@ public void TestUpdateBinaryEight() @Test public void TestUpdateBinaryTwentyPointFive() { - String expected = "10100"; + String expected = + "╔════════════════════════════════════════════════╗\n" + + "║ ║\n" + + "║ 10100 ║\n" + + "║ BIN ║\n" + + "╚════════════════════════════════════════════════╝\n"; Display TestDisplay = new Display(); TestDisplay.setDisplay(20.5); TestDisplay.setMode(Display.Modes.BINARY); @@ -107,4 +118,80 @@ public void TestAbsoluteValueOfZero() assertEquals(expected, actual); } + + @Test + public void TestSetModeOCT() + { + Display.Modes expected = Display.Modes.OCTAL; + Display TestDisplay = new Display(); + TestDisplay.setMode(Display.Modes.OCTAL); + Display.Modes actual = TestDisplay.getMode(); + + assertEquals(expected, actual); + } + + @Test + public void TestSetModeBINARY() + { + Display.Modes expected = Display.Modes.BINARY; + Display TestDisplay = new Display(); + TestDisplay.setMode(Display.Modes.BINARY); + Display.Modes actual = TestDisplay.getMode(); + + assertEquals(expected, actual); + } + + @Test + public void TestSetModeDEC() + { + Display.Modes expected = Display.Modes.DEC; + Display TestDisplay = new Display(); + TestDisplay.setMode(Display.Modes.DEC); + Display.Modes actual = TestDisplay.getMode(); + + assertEquals(expected, actual); + } + + @Test + public void TestSetModeCycleFiveTimes() + { + Display.Modes expected = Display.Modes.BINARY; + Display TestDisplay = new Display(); + TestDisplay.setMode(); + TestDisplay.setMode(); + TestDisplay.setMode(); + TestDisplay.setMode(); + TestDisplay.setMode(); + Display.Modes actual = TestDisplay.getMode(); + + assertEquals(expected, actual); + } + + @Test + public void TestNaNDisplaysError () + { + String expected = + "╔════════════════════════════════════════════════╗\n" + + "║ ERR ║\n" + + "║ ERR ║\n" + + "║ ERR ║\n" + + "╚════════════════════════════════════════════════╝\n"; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(6.0/0.0); + String actual = TestDisplay.update(); + + assertEquals(expected, actual); + } + + @Test + public void TestNullDisplaysError() + { + + } + + @Test + public void TestClearVoidsError() + { + + } } \ No newline at end of file From bd6cce4c895daa95f73f02559a3ba19429c173d6 Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 07:30:57 -0500 Subject: [PATCH 33/53] BoxMaker tests --- .../scientificcalculator/BoxMaker.java | 5 +- .../scientificcalculator/Display.java | 6 +- .../scientificcalculator/BoxMakerTest.java | 119 ++++++++++++++++++ .../scientificcalculator/DisplayTest.java | 26 +++- 4 files changed, 152 insertions(+), 4 deletions(-) create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/BoxMakerTest.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java index f6cd44a5..21e8173e 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java @@ -18,7 +18,10 @@ public int getWidth() { public void setWidth(int newWidth) { - width = newWidth; + if(newWidth > 0 && newWidth < 151) + { + width = newWidth; + } } public String draw(String ... input) { diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 36bc2498..5a5ce6fc 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -19,7 +19,6 @@ public Display() displayWidth = 50; displayBox = new BoxMaker(displayWidth); isRadians = false; -// currentOperation = ""; error = false; } @@ -129,6 +128,9 @@ public void setMode() { setMode(Modes.DEC); break; } + + // Considering updating currentVal here, but makes math more difficult + // since Math assumes decimal math. } public Modes getMode() @@ -138,7 +140,9 @@ public Modes getMode() public void clear() { currentValue = 0.0; + error = false; update(); + // Send a command to input to remove last operation and last value input } public Double invSign() diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/BoxMakerTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/BoxMakerTest.java new file mode 100644 index 00000000..3815e92e --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/BoxMakerTest.java @@ -0,0 +1,119 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class BoxMakerTest { + + @Test + public void TestGetWidthGeneric() + { + int expected = 30; + BoxMaker TestBoxMaker = new BoxMaker(); + int actual = TestBoxMaker.getWidth(); + + assertEquals(expected, actual); + } + + @Test + public void TestGetWidthSizeTwelve() + { + int expected = 12; + BoxMaker TestBoxMaker = new BoxMaker(12); + int actual = TestBoxMaker.getWidth(); + + assertEquals(expected, actual); + } + + @Test + public void TestSetWidth() + { + int expected = 55; + BoxMaker TestBoxMaker = new BoxMaker(); + TestBoxMaker.setWidth(55); + int actual = TestBoxMaker.getWidth(); + + assertEquals(expected, actual); + } + + @Test + public void TestSetWidthTooSmall() + { + int expected = 30; + BoxMaker TestBoxMaker = new BoxMaker(); + TestBoxMaker.setWidth(-9); + int actual = TestBoxMaker.getWidth(); + + assertEquals(expected, actual); + } + + @Test + public void TestSetWidthTooBig() + { + int expected = 30; + BoxMaker TestBoxMaker = new BoxMaker(); + TestBoxMaker.setWidth(4000); + int actual = TestBoxMaker.getWidth(); + + assertEquals(expected, actual); + } + + @Test + public void TestDraw() + { + String expected = + "╔════════╗\n" + + "║ hello║\n" + + "╚════════╝\n"; + + BoxMaker TestBoxMaker = new BoxMaker(); + TestBoxMaker.setWidth(10); + String actual = TestBoxMaker.draw("Hello"); + } + + @Test + public void TestDrawTwoLines() + { + String expected = + "╔═════╗\n" + + "║hello║\n" + + "║James║\n" + + "╚═════╝\n"; + + + BoxMaker TestBoxMaker = new BoxMaker(); + TestBoxMaker.setWidth(7); + String actual = TestBoxMaker.draw("Hello", "James"); + } + + @Test + public void TestDrawTooLong() + { + String expected = + "╔═════╗\n" + + "║hello║\n" + + "║ ║\n" + + "╚═════╝\n"; + + + BoxMaker TestBoxMaker = new BoxMaker(); + TestBoxMaker.setWidth(7); + String actual = TestBoxMaker.draw("Hello James"); + } + + @Test + public void TestDrawNothing() + { + String expected = + "╔═════╗\n" + + "║ ║\n" + + "║ ║\n" + + "╚═════╝\n"; + + + BoxMaker TestBoxMaker = new BoxMaker(); + TestBoxMaker.setWidth(7); + String actual = TestBoxMaker.draw(""); + } +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java index 3d4c4816..5412e05a 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java @@ -184,14 +184,36 @@ public void TestNaNDisplaysError () } @Test - public void TestNullDisplaysError() + public void TestClearVoidsError() { + String expected = + "╔════════════════════════════════════════════════╗\n" + + "║ ║\n" + + "║ 0 ║\n" + + "║ ║\n" + + "╚════════════════════════════════════════════════╝\n"; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(6.0/0.0); + TestDisplay.clear(); + String actual = TestDisplay.update(); + assertEquals(expected, actual); } @Test - public void TestClearVoidsError() + public void TestMaxDisplaySize() { + String expected = + "╔════════════════════════════════════════════════╗\n" + + "║ ║\n" + + "║ 100000000000000000000000000000000000000000000 ║\n" + + "║ ║\n" + + "╚════════════════════════════════════════════════╝\n"; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(140737488355328.0); + TestDisplay.setMode(Display.Modes.BINARY); + String actual = TestDisplay.update(); + assertEquals(expected, actual); } } \ No newline at end of file From e1e1c731ceae1ace0f0cdd1029e1b6ff8dab812b Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 08:15:51 -0500 Subject: [PATCH 34/53] Sleep --- .../scientificcalculator/BoxMaker.java | 2 +- .../scientificcalculator/Display.java | 19 ++++- .../scientificcalculator/DisplayTest.java | 77 ++++++++++++++++++- 3 files changed, 93 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java index 21e8173e..c495a143 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java @@ -55,4 +55,4 @@ public String draw(String ... input) { return output.toString(); } -} +} \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 5a5ce6fc..6e01a0ce 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -1,6 +1,7 @@ package com.zipcodewilmington.scientificcalculator; import javax.swing.*; +import java.io.DataInput; public class Display { private int displayWidth; @@ -24,9 +25,7 @@ public Display() public void setDisplay(Double inputValue) { - if (inputValue == Double.NaN || - inputValue == Double.POSITIVE_INFINITY || - inputValue == Double.NEGATIVE_INFINITY) + if (inputValue.isNaN() || inputValue.isInfinite()) { error = true; } @@ -141,6 +140,8 @@ public Modes getMode() public void clear() { currentValue = 0.0; error = false; + isRadians = false; + mode = Modes.DEC; update(); // Send a command to input to remove last operation and last value input } @@ -161,4 +162,16 @@ public Double absoluteValue() return currentValue; } } + + public void toggleRadians() + { + isRadians = !isRadians; + } + + public Boolean getIsRadians() + { + return isRadians; + } + + // Make a toggle to switch from normal notation to scientific notation } \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java index 5412e05a..42526e43 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java @@ -167,6 +167,46 @@ public void TestSetModeCycleFiveTimes() assertEquals(expected, actual); } + @Test + public void TestToggleRadians() + { + Boolean expected = true; + Display TestDisplay = new Display(); + TestDisplay.toggleRadians(); + Boolean actual = TestDisplay.getIsRadians(); + + assertEquals(expected, actual); + } + + @Test + public void TestToggleRadiansFourHundredTimes() + { + Boolean expected = false; + Display TestDisplay = new Display(); + for(int i = 0; i < 400; i++) + { + TestDisplay.toggleRadians(); + } + Boolean actual = TestDisplay.getIsRadians(); + + assertEquals(expected, actual); + } + + @Test + public void TestDisplayRadians() + { + String expected = + "╔════════════════════════════════════════════════╗\n" + + "║ RAD ║\n" + + "║ 90 ║\n" + + "║ ║\n" + + "╚════════════════════════════════════════════════╝\n"; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(90.0); + TestDisplay.toggleRadians(); + String actual = TestDisplay.update(); + } + @Test public void TestNaNDisplaysError () { @@ -207,7 +247,7 @@ public void TestMaxDisplaySize() "╔════════════════════════════════════════════════╗\n" + "║ ║\n" + "║ 100000000000000000000000000000000000000000000 ║\n" + - "║ ║\n" + + "║ BIN ║\n" + "╚════════════════════════════════════════════════╝\n"; Display TestDisplay = new Display(); TestDisplay.setDisplay(140737488355328.0); @@ -216,4 +256,39 @@ public void TestMaxDisplaySize() assertEquals(expected, actual); } + + @Test + public void TestMaxDisplaySizeTwo() + { + String expected = + "╔════════════════════════════════════════════════╗\n" + + "║ ║\n" + + "║ 9.9999999999999999999999999999999999999999999 ║\n" + + "║ ║\n" + + "╚════════════════════════════════════════════════╝\n"; + + Display TestDisplay = new Display(); + TestDisplay.setDisplay(9.9999999999999999999999999999999999999999999); + String actual = TestDisplay.update(); + + assertEquals(expected, actual); + } + + @Test + public void TextDisplayPi() + { + String expected = + "╔════════════════════════════════════════════════╗\n" + + "║ ║\n" + + "║ 3.141592653589793 ║\n" + + "║ ║\n" + + "╚════════════════════════════════════════════════╝\n"; + + Display TestDisplay = new Display(); + TestDisplay.setDisplay(Math.PI); + String actual = TestDisplay.update(); + + assertEquals(expected, actual); + + } } \ No newline at end of file From 414e2bb7dacfa1ddbc380b8bbcc50d08444dd38a Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Sun, 9 Feb 2020 11:19:03 -0500 Subject: [PATCH 35/53] Adding Trig/Log/OtherFunctions --- pom.xml | 8 + .../scientificcalculator/Logarithm.java | 48 +++++ .../scientificcalculator/OtherFunctions.java | 41 ++++ .../scientificcalculator/Trig.java | 101 +++++++++ .../scientificcalculator/TestLogarithm.java | 203 ++++++++++++++++++ .../TestMainApplication.java | 2 +- .../TestOtherFunctions.java | 120 +++++++++++ .../scientificcalculator/TestTrig.java | 132 ++++++++++++ 8 files changed, 654 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/OtherFunctions.java create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/Trig.java create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/TestLogarithm.java rename src/test/java/com/zipcodewilmington/{scientific_calculator => scientificcalculator}/TestMainApplication.java (58%) create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/TestOtherFunctions.java create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/TestTrig.java diff --git a/pom.xml b/pom.xml index e7cb4f6b..a578ffa5 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,14 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + + junit + junit + RELEASE + test + + \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java new file mode 100644 index 00000000..d1aa5290 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java @@ -0,0 +1,48 @@ +package com.zipcodewilmington.scientificcalculator; + +public class Logarithm { + + Double x; + + public Logarithm() { + + x =0.0; + + } + + public static double Log(Double x) { + + if (x<=0) + return 0; + + return Math.log10(x); + + } + + public static Double InvLog(Double x) { + + return Math.pow(10,x); + + } + + public static Double NLog(Double x) { + + if (x<=0) + return 0.0; + + return Math.log(x); + + } + + public static double InvNLog(Double x) { + + return (Math.pow(Math.exp(1.0), x)); + + } + + +} + + + + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/OtherFunctions.java b/src/main/java/com/zipcodewilmington/scientificcalculator/OtherFunctions.java new file mode 100644 index 00000000..7200921d --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/OtherFunctions.java @@ -0,0 +1,41 @@ +package com.zipcodewilmington.scientificcalculator; + + +public class OtherFunctions { + + Double x; + + public OtherFunctions() { + + x = 0.0; + } + + public static int Fact(int x){ + + if (x<0) + return 0; + + if (x == 0 || x == 1) + return 1; + + return x*Fact(x-1); + } + + public static int Fibon(int x) { + + if (x<0) + return 0; + + if (0<=x && x<=1) + return x; + + return Fibon(x-1) + Fibon(x-2); + + + } + +} + + + + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Trig.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Trig.java new file mode 100644 index 00000000..16157920 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Trig.java @@ -0,0 +1,101 @@ +package com.zipcodewilmington.scientificcalculator; + +public class Trig { + + Double x; + + public Trig() { + + x = 0.0; + } + + public static Double Sin(Double x, String unitOfMeasurement) + { + if("DEG".equals(unitOfMeasurement)) + { + if (x >= 360) { + x = x % 360; + } + // convert degrees to radians + double radians = Math.toRadians(x); + + return Math.sin(radians); + + } + else + // sin() method to get the value + return Math.sin(x); + + } + + + + + public static Double Cos(Double x, String unitOfMeasurement) { + if ("DEG".equals(unitOfMeasurement)) { + + if (x >= 360) { + x = x % 360; + } + + // convert degrees to radians + double radians = Math.toRadians(x); + return Math.cos(radians); + } + + else + + // cos() method to get the value + return Math.cos(x); + + } + + public static Double Tan(Double x, String unitOfMeasurement) { + + if ("DEG".equals(unitOfMeasurement)) { + + if (x >= 360) { + x = x % 360; + } + // convert degrees to radians + double radians = Math.toRadians(x); + return Math.tan(radians); + } + + else + + // tan() method to get the value + return Math.tan(x); + + } + + public static Double InvSin(Double x) + { + + // convert degrees to radians + double radians = Math.toRadians(x); + + // InvSin() method to get the value + return Math.toDegrees(Math.asin(x)); + } + + public static Double InvCos(Double x) + { + // convert degrees to radians + double radians = Math.toRadians(x); + + // InvCos() method to get the value + return Math.toDegrees(Math.acos(x)); + + } + + public static Double InvTan(Double x) + { + // convert degrees to radians + double radians = Math.toRadians(x); + + // InvTan() method to get the value + return Math.toDegrees(Math.atan(x)); + } + + } diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/TestLogarithm.java b/src/test/java/com/zipcodewilmington/scientificcalculator/TestLogarithm.java new file mode 100644 index 00000000..1c435067 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/TestLogarithm.java @@ -0,0 +1,203 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class TestLogarithm { + + ////********* ***********//////////////////// + + @Test + public void logNegative() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.0; + actual= Logarithm.Log(-1.0); + assertEquals(expected,actual); + + } + + @Test + public void logZero() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.0; + actual= Logarithm.Log(0.0); + assertEquals(expected,actual); + + } + + @Test + public void logOne() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.0; + actual= Logarithm.Log(1.0); + assertEquals(expected,actual); + + } + + @Test + public void logDecimal() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.17609125905568124; + actual= Logarithm.Log(1.5); + assertEquals(expected,actual); + + } + + @Test + public void logThousand() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 3.0; + actual= Logarithm.Log(1000.0); + assertEquals(expected,actual); + + } + + + ////********* ***********//////////////////// + + @Test + public void invLogNegative() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.001; + actual= Logarithm.InvLog(-3.0); + assertEquals(expected,actual); + + } + + @Test + public void invLogZero() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 1.0; + actual= Logarithm.InvLog(0.0); + assertEquals(expected,actual); + + } + + @Test + public void invLogThree() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 1000.0; + actual= Logarithm.InvLog(3.0); + assertEquals(expected,actual); + + } + + @Test + public void invLogDecimal() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 1584.893192461114; + actual= Logarithm.InvLog(3.2); + assertEquals(expected,actual); + + } + + ////********* ***********//////////////////// + + @Test + public void NLogNegative() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.0; + actual= Logarithm.NLog(-1.0); + assertEquals(expected,actual); + } + @Test + public void NLogZero() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.0; + actual= Logarithm.NLog(0.0); + assertEquals(expected,actual); + } + + @Test + public void NLogOne() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.0; + actual= Logarithm.NLog(1.0); + assertEquals(expected,actual); + } + + @Test + public void NLogDecimal() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 1.1314021114911006; + actual= Logarithm.NLog(3.1); + assertEquals(expected,actual); + } + + @Test + public void invNLogNegative() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.36787944117144233; + actual= Logarithm.InvNLog(-1.0); + assertEquals(expected,actual); + } + + @Test + public void invNLogZero() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 1.0; + actual= Logarithm.InvNLog(0.0); + assertEquals(expected,actual); + } + + @Test + public void invNLogOne() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 2.718281828459045; + actual= Logarithm.InvNLog(1.0); + assertEquals(expected,actual); + } + + @Test + public void invNLogDecimal() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 0.33287108369807955; + actual= Logarithm.InvNLog(-1.1); + assertEquals(expected,actual); + } + + @Test + public void invNLogFour() { + + Logarithm TestLogarithm = new Logarithm(); + Double actual; + Double expected = 54.59815003314423; + actual= Logarithm.InvNLog((double)4); + assertEquals(expected,actual); + } +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientificcalculator/TestMainApplication.java similarity index 58% rename from src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java rename to src/test/java/com/zipcodewilmington/scientificcalculator/TestMainApplication.java index 94e8d987..e8ccb8dd 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/TestMainApplication.java @@ -1,4 +1,4 @@ -package com.zipcodewilmington.scientific_calculator; +package com.zipcodewilmington.scientificcalculator; /** * Created by leon on 2/9/18. diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/TestOtherFunctions.java b/src/test/java/com/zipcodewilmington/scientificcalculator/TestOtherFunctions.java new file mode 100644 index 00000000..ab23f0eb --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/TestOtherFunctions.java @@ -0,0 +1,120 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class TestOtherFunctions { + + @Test + public void FactNegativeOne() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected=0; + actual= OtherFunctions.Fact(-1); + assertEquals(expected,actual); + + } + + @Test + public void FactZero() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected=1; + actual= OtherFunctions.Fact(1); + assertEquals(expected,actual); + + } + + @Test + public void FactOne() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected=1; + actual= OtherFunctions.Fact(1); + assertEquals(expected,actual); + + } + + @Test + public void FactFive() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected=120; + actual= OtherFunctions.Fact(5); + assertEquals(expected,actual); + + } + + ///////******************* **************************//////////////// + + @Test + public void FibonNegativeOne() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected = 0; + actual = OtherFunctions.Fibon(-1); + assertEquals(expected, actual); + + } + + @Test + public void FibonZero() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected=0; + actual= OtherFunctions.Fibon(0); + assertEquals(expected,actual); + + } + + @Test + public void FibonOne() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected=1; + actual= OtherFunctions.Fibon(1); + assertEquals(expected,actual); + + } + + @Test + public void FibonTwo() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected=1; + actual= OtherFunctions.Fibon(2); + assertEquals(expected,actual); + + } + + @Test + public void FibonThree() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected=2; + actual= OtherFunctions.Fibon(3); + assertEquals(expected,actual); + + } + + @Test + public void FibonTen() { + + OtherFunctions OtherFunctionsTest = new OtherFunctions(); + int actual; + int expected=55; + actual= OtherFunctions.Fibon(10); + assertEquals(expected,actual); + + } +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/TestTrig.java b/src/test/java/com/zipcodewilmington/scientificcalculator/TestTrig.java new file mode 100644 index 00000000..ad45e5ba --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/TestTrig.java @@ -0,0 +1,132 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class TestTrig { + + @Test + public void sinPositive(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=1.0; + actual= Trig.Sin((double)450, "DEG"); + assertEquals(expected,actual); + } + + @Test + public void sinNegative(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=0.6832837250355236; + actual= Trig.Sin((double)-450, "RAD"); + assertEquals(expected,actual); + } + + + @Test + public void cosPositive(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=0.8746197071393957; + actual= Trig.Cos((double)389, "DEG"); + assertEquals(expected,actual); + } + + @Test + public void cosNegative(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=0.8485862232545117; + actual= Trig.Cos((double)-389, "RAD"); + assertEquals(expected,actual, 0.001); + } + + @Test + public void tanPositive(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=1.633123935319537E16; + actual= Trig.Tan((double)450, "DEG"); + assertEquals(expected,actual, 1.0001); + } + + @Test + public void tanNegative(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=-0.9358090133927123; + actual=(Trig.Tan((double)-450, "RAD")); + assertEquals(expected,actual, 1.001); + } + + @Test + public void invSinNegative(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=-60.0; + actual= Trig.InvSin(-0.8660254); + assertEquals(expected,actual, .0001); + } + + @Test + public void invSinPositive(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=45.0; + actual= Trig.InvSin(0.7071068); + assertEquals(expected,actual, .0001); + } + + @Test + public void invCosPositive(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=45.0; + actual= Trig.InvCos(0.7071068); + assertEquals(expected,actual, .0001); + + } + + @Test + public void invCosNegative(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=150.0; + actual= Trig.InvCos(-0.8660254); + assertEquals(expected,actual, 1.0001); + + } + + @Test + public void invTanPositive(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=60.0; + actual= Trig.InvTan(1.732050808); + assertEquals(expected,actual, 1.0001); + } + + @Test + public void invTanNegative(){ + + Trig TestTrig=new Trig(); + Double actual; + Double expected=-30.0; + actual= Trig.InvTan(-0.577350269); + assertEquals(expected,actual, 1.0001); + } + } + From b36843733538a55a8f564d89878835a48cd195e2 Mon Sep 17 00:00:00 2001 From: Zanetta Norris Date: Sun, 9 Feb 2020 11:35:06 -0500 Subject: [PATCH 36/53] AddedConversion Math Class and Conversion Math Test Class --- .../scientificcalculator/ConversionMath.java | 9 +++++++++ .../TestConversionMath.java | 19 +++++++++++++++++++ 2 files changed, 28 insertions(+) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java new file mode 100644 index 00000000..f1b670eb --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java @@ -0,0 +1,9 @@ +package com.zipcodewilmington.scientificcalculator; + +public class ConversionMath { + + public static Double feetToMeters (Double numberOne) { + return (numberOne/3281.0) *1000.0; + } + +} diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java new file mode 100644 index 00000000..e7bd4853 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java @@ -0,0 +1,19 @@ +package com.zipcodewilmington.scientific_calculator; + +import com.zipcodewilmington.scientificcalculator.BasicMath; +import com.zipcodewilmington.scientificcalculator.ConversionMath; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class TestConversionMath { + @Test + public void TestFeetToMetersWhole() + { + ConversionMath feetToMetersTest = new ConversionMath(); + Double actual; + Double expected = 0.30478512648582745; + actual = feetToMetersTest.feetToMeters(1.0); + assertEquals(expected, actual); + } +} From ba2ba6c0a42b85879a0a73413853181fa23b5f5e Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 12:03:09 -0500 Subject: [PATCH 37/53] Nervous about pull --- .../scientificcalculator/BoxMaker.java | 9 +- .../scientificcalculator/MainApplication.java | 25 ++++-- .../scientificcalculator/Prompt.java | 82 +++++++++++++++++++ 3 files changed, 105 insertions(+), 11 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java index c495a143..59383cae 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java @@ -1,5 +1,7 @@ package com.zipcodewilmington.scientificcalculator; +import java.util.ArrayList; + public class BoxMaker { private int width; @@ -28,13 +30,12 @@ public String draw(String ... input) { StringBuilder output = new StringBuilder(); output.append("╔"); - for(int i = 0; i < width - 2; i++) { + for (int i = 0; i < width - 2; i++) { output.append("═"); } output.append("╗\n"); - for (String element : input) - { + for (String element : input) { String line = ""; StringBuilder lineFormat = new StringBuilder(); lineFormat.append("%"); @@ -48,7 +49,7 @@ public String draw(String ... input) { } output.append("╚"); - for(int i = 0; i < width - 2; i++) { + for (int i = 0; i < width - 2; i++) { output.append("═"); } output.append("╝\n"); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 0adeabf8..1d05957d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -6,13 +6,24 @@ */ 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 Mr. Math!"); + // String s = Console.getStringInput("Enter a string"); + // Integer i = Console.getIntegerInput("Enter an integer"); + // Double d = Console.getDoubleInput("Enter a double."); - Console.println("The user input %s as a string", s); - Console.println("The user input %s as a integer", i); - Console.println("The user input %s as a d", d); + // Console.println("The user input %s as a string", s); + // Console.println("The user input %s as a integer", i); + // Console.println("The user input %s as a d", d); + + Display display = new Display(); + Prompt menu = new Prompt(); + String userInput = ""; + String message; + do { + display.update(); + userInput = Console.getStringInput(" "); + menu.input(userInput); + message = menu.getMessage(); + } while(!userInput.equals(":q")); } } \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java new file mode 100644 index 00000000..48931950 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java @@ -0,0 +1,82 @@ +package com.zipcodewilmington.scientificcalculator; + +import java.util.ArrayList; +import java.util.*; + +public class Prompt { + private String inputOperation; + private String previousOperation; + private Double inputValue; + private String message; + private List validOperations = new ArrayList(); + + public Prompt() + { + inputOperation = ""; + previousOperation = ""; + inputValue = 0.0; + message = ""; + validOperations.add("+"); + validOperations.add("-"); + validOperations.add("*"); + validOperations.add("/"); + validOperations.add("exp"); + validOperations.add("sq"); + validOperations.add("sqrt"); + } + + public String callMenu() + { + BoxMaker menuBox = new BoxMaker(120); + + return menuBox.draw( + String.format("%-100s", "OPERATION | DESCRIPTION"), + String.format("%-100s", "+ | Adds the display value to next input"), + String.format("%-100s", "- | Subtracts the next input from display value"), + String.format("%-100s", "* | Multiplies display value with next input"), + String.format("%-100s", "/ | Divides display value by next input"), + String.format("%-100s", "exp | Display value to power of next input"), + String.format("%-100s", "sq | Display value multiplied by itself"), + String.format("%-100s", "sqrt | Square root of display value")); + } + + public String getMessage() + { + return message; + } + public Double getInputValue(Double val) + { + return inputValue; + } + + public void input(String in) + { + Boolean isANumber = true; + + try + { + Double num = Double.parseDouble(in); + } + catch (NumberFormatException error) + { + isANumber = false; + } + + if(isANumber) + { + inputValue = Double.parseDouble(in); + } + else + { + if(validOperations.contains(in)) + { + previousOperation = inputOperation; + inputOperation = in; + } + else // Throw error + { + message = "Invalid user input"; + } + } + } +} From 36671816a2954542b481c7f0b6b99ed85fcd055c Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Sun, 9 Feb 2020 12:20:47 -0500 Subject: [PATCH 38/53] minor changes --- .../zipcodewilmington/scientificcalculator/Logarithm.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java index d1aa5290..b7f38bb6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java @@ -10,10 +10,10 @@ public Logarithm() { } - public static double Log(Double x) { + public static Double Log(Double x) { if (x<=0) - return 0; + return 0.0; return Math.log10(x); @@ -34,7 +34,7 @@ public static Double NLog(Double x) { } - public static double InvNLog(Double x) { + public static Double InvNLog(Double x) { return (Math.pow(Math.exp(1.0), x)); From b2821935f75edf7345d78789ab5dabd16ce6ac3a Mon Sep 17 00:00:00 2001 From: Zanetta Norris Date: Sun, 9 Feb 2020 12:22:35 -0500 Subject: [PATCH 39/53] Added Feet to Meters conversion --- .../zipcodewilmington/scientificcalculator/BasicMath.java | 2 +- .../scientificcalculator/ConversionMath.java | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java index a955c769..2673b68d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java @@ -12,7 +12,7 @@ public static Double multiplication (Double numberOne, Double numberTwo) { return numberOne * numberTwo; } public static Double division (Double numberOne, Double numberTwo) { - return numberOne / numberTwo; + return numberOne / numberTwo; } public static Double exponent (Double numberOne, Double numberTwo){ return Math.pow(numberOne, numberTwo); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java index f1b670eb..a4947aef 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java @@ -3,7 +3,11 @@ public class ConversionMath { public static Double feetToMeters (Double numberOne) { - return (numberOne/3281.0) *1000.0; + return numberOne / 3.281.0; + } + + public static Double metersToFeet (Double numberOne) { + return numberOne * 3.28084; } } From d41fcc5d00ded0d3ae598585906b641e9c7f33ef Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Sun, 9 Feb 2020 12:52:19 -0500 Subject: [PATCH 40/53] Minor changes --- blah.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 blah.txt diff --git a/blah.txt b/blah.txt deleted file mode 100644 index e69de29b..00000000 From 139b464a1901d02fec1e601d6b003c29a78ed2f9 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Sun, 9 Feb 2020 12:56:32 -0500 Subject: [PATCH 41/53] Minor changes --- .../com/zipcodewilmington/scientificcalculator/Logarithm.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java index b7f38bb6..d44adf15 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java @@ -10,7 +10,7 @@ public Logarithm() { } - public static Double Log(Double x) { + public static double Log(Double x) { if (x<=0) return 0.0; @@ -34,7 +34,7 @@ public static Double NLog(Double x) { } - public static Double InvNLog(Double x) { + public static double InvNLog(Double x) { return (Math.pow(Math.exp(1.0), x)); From 82ed978e966f1aed91db2270348e8268d370d472 Mon Sep 17 00:00:00 2001 From: Sandeep Naraya Date: Sun, 9 Feb 2020 13:06:37 -0500 Subject: [PATCH 42/53] Minor changes --- .../com/zipcodewilmington/scientificcalculator/Logarithm.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java index d44adf15..b7f38bb6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Logarithm.java @@ -10,7 +10,7 @@ public Logarithm() { } - public static double Log(Double x) { + public static Double Log(Double x) { if (x<=0) return 0.0; @@ -34,7 +34,7 @@ public static Double NLog(Double x) { } - public static double InvNLog(Double x) { + public static Double InvNLog(Double x) { return (Math.pow(Math.exp(1.0), x)); From ea2f3b1b7f30cfa8e391c5d6434188c29233886e Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 13:11:57 -0500 Subject: [PATCH 43/53] Pull from dev --- .../scientificcalculator/BoxMaker.java | 2 +- .../scientificcalculator/MainApplication.java | 16 ++++++--- .../scientificcalculator/Menu.java | 31 ++++++++++++++++ .../scientificcalculator/Prompt.java | 31 ++-------------- .../scientificcalculator/ValidOperations.java | 35 +++++++++++++++++++ 5 files changed, 82 insertions(+), 33 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/ValidOperations.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java index 59383cae..d4587d08 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BoxMaker.java @@ -20,7 +20,7 @@ public int getWidth() { public void setWidth(int newWidth) { - if(newWidth > 0 && newWidth < 151) + if(newWidth > 3 && newWidth < 151) { width = newWidth; } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 1d05957d..619a18c5 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -7,6 +7,8 @@ public class MainApplication { public static void main(String[] args) { Console.println("Welcome to Mr. Math!"); + Console.println("To see a valid list of commands, type 'menu' at any time"); + Console.println("When you are finish with Mr. Math, feel free to quit by entering ':q'"); // String s = Console.getStringInput("Enter a string"); // Integer i = Console.getIntegerInput("Enter an integer"); // Double d = Console.getDoubleInput("Enter a double."); @@ -16,14 +18,20 @@ public static void main(String[] args) { // Console.println("The user input %s as a d", d); Display display = new Display(); - Prompt menu = new Prompt(); + Prompt user = new Prompt(); String userInput = ""; - String message; + do { display.update(); userInput = Console.getStringInput(" "); - menu.input(userInput); - message = menu.getMessage(); + if(userInput.equalsIgnoreCase("menu")) + { + Console.print(Menu.callMenu()); + } + else if(!ValidOperations.isValid(userInput)) + { + Console.println("Invalid input. Check 'menu' for valid commands."); + } } while(!userInput.equals(":q")); } } \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java new file mode 100644 index 00000000..359d5e44 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java @@ -0,0 +1,31 @@ +package com.zipcodewilmington.scientificcalculator; + +public class Menu +{ + public void Menu(){ + } + + public static String callMenu() + { + BoxMaker menuBox = new BoxMaker(120); + + return menuBox.draw( + String.format("%-100s", "c | Resets the display to 0"), + String.format("%-100s", "m | Store display to memory"), + String.format("%-100s", "m+ | Recall stored memory as user input"), + String.format("%-100s", "mc | Reset memory to 0"), + String.format("%-100s", "inv | Invert the sign of the display value"), + String.format("%-100s", "bin | Set mode to binary"), + String.format("%-100s", "oct | Set mode to octal"), + String.format("%-100s", "dec | Set mode to decimal"), + String.format("%-100s", "hex | Set mode to hexadecimal"), + String.format("%-100s", "mode | Invert the sign of the display value"), + String.format("%-100s", "+ | Adds the display value to next input"), + String.format("%-100s", "- | Subtracts the next input from display value"), + String.format("%-100s", "* | Multiplies display value with next input"), + String.format("%-100s", "/ | Divides display value by next input"), + String.format("%-100s", "exp | Display value to power of next input"), + String.format("%-100s", "sq | Display value multiplied by itself"), + String.format("%-100s", "sqrt | Square root of display value")); + } +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java index 48931950..17943151 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java @@ -1,14 +1,11 @@ package com.zipcodewilmington.scientificcalculator; -import java.util.ArrayList; -import java.util.*; - public class Prompt { private String inputOperation; private String previousOperation; private Double inputValue; private String message; - private List validOperations = new ArrayList(); + public Prompt() { @@ -16,28 +13,6 @@ public Prompt() previousOperation = ""; inputValue = 0.0; message = ""; - validOperations.add("+"); - validOperations.add("-"); - validOperations.add("*"); - validOperations.add("/"); - validOperations.add("exp"); - validOperations.add("sq"); - validOperations.add("sqrt"); - } - - public String callMenu() - { - BoxMaker menuBox = new BoxMaker(120); - - return menuBox.draw( - String.format("%-100s", "OPERATION | DESCRIPTION"), - String.format("%-100s", "+ | Adds the display value to next input"), - String.format("%-100s", "- | Subtracts the next input from display value"), - String.format("%-100s", "* | Multiplies display value with next input"), - String.format("%-100s", "/ | Divides display value by next input"), - String.format("%-100s", "exp | Display value to power of next input"), - String.format("%-100s", "sq | Display value multiplied by itself"), - String.format("%-100s", "sqrt | Square root of display value")); } public String getMessage() @@ -49,7 +24,7 @@ public Double getInputValue(Double val) return inputValue; } - public void input(String in) + public void input(String in, Double displayValue) { Boolean isANumber = true; @@ -68,7 +43,7 @@ public void input(String in) } else { - if(validOperations.contains(in)) + if(ValidOperations.isValid(in)) { previousOperation = inputOperation; inputOperation = in; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ValidOperations.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ValidOperations.java new file mode 100644 index 00000000..0cb0e65c --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ValidOperations.java @@ -0,0 +1,35 @@ +package com.zipcodewilmington.scientificcalculator; + +import java.util.ArrayList; +import java.util.List; + +public class ValidOperations +{ + private static List listOfValid = new ArrayList(); + + public ValidOperations() + { + listOfValid.add("c"); + listOfValid.add("m+"); + listOfValid.add("m"); + listOfValid.add("mc"); + listOfValid.add("inv"); + listOfValid.add("+"); + listOfValid.add("-"); + listOfValid.add("*"); + listOfValid.add("/"); + listOfValid.add("exp"); + listOfValid.add("sq"); + listOfValid.add("sqrt"); + listOfValid.add("mode"); + listOfValid.add("bin"); + listOfValid.add("oct"); + listOfValid.add("dec"); + listOfValid.add("hex"); + } + + public static Boolean isValid(String op) + { + return listOfValid.contains(op); + } +} From eddbc271ceec188a59197267a3e8b8fc55b3fe60 Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 14:26:28 -0500 Subject: [PATCH 44/53] Adding valid operations --- .../InputErrorHandler.java | 54 ++++++++++++ .../scientificcalculator/MainApplication.java | 14 ++- .../scientificcalculator/Menu.java | 21 ++++- .../scientificcalculator/ValidOperations.java | 13 +++ .../InputErrorHandlerTest.java | 88 +++++++++++++++++++ .../ValidOperationsTest.java | 47 ++++++++++ 6 files changed, 233 insertions(+), 4 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/InputErrorHandlerTest.java create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/ValidOperationsTest.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java b/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java new file mode 100644 index 00000000..3cd23bcd --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java @@ -0,0 +1,54 @@ +package com.zipcodewilmington.scientificcalculator; + +import java.util.ArrayList; +import java.util.List; + +public class InputErrorHandler { + private static List listOfValid = new ArrayList(); + + public InputErrorHandler() + { + listOfValid.add("c"); + listOfValid.add("m+"); + listOfValid.add("m"); + listOfValid.add("mc"); + listOfValid.add("inv"); + listOfValid.add("+"); + listOfValid.add("-"); + listOfValid.add("*"); + listOfValid.add("/"); + listOfValid.add("exp"); + listOfValid.add("sq"); + listOfValid.add("sqrt"); + listOfValid.add("mode"); + listOfValid.add("bin"); + listOfValid.add("oct"); + listOfValid.add("dec"); + listOfValid.add("hex"); + } + + public static Boolean validOp(String op) + { + return listOfValid.contains(op); + } + + public static Boolean validNumber(String in) + { + Boolean isANumber = true; + + try + { + Double num = Double.parseDouble(in); + } catch (NumberFormatException error) { + isANumber = false; + } + + if (isANumber) + { + return true; + } else + { + return false; + } + } +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 619a18c5..1df4bb4b 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -24,14 +24,22 @@ public static void main(String[] args) { do { display.update(); userInput = Console.getStringInput(" "); - if(userInput.equalsIgnoreCase("menu")) + + if (userInput.equals("menu")) { Console.print(Menu.callMenu()); } - else if(!ValidOperations.isValid(userInput)) + else if(InputErrorHandler.validNumber(userInput)) + { + display.setDisplay(Double.parseDouble(userInput)); + } + else if(InputErrorHandler.validOp(userInput)) { - Console.println("Invalid input. Check 'menu' for valid commands."); + } + // If number, change display value + // Is it menu? List menu + // Call actual operations } while(!userInput.equals(":q")); } } \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java index 359d5e44..950bcdbe 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java @@ -26,6 +26,25 @@ public static String callMenu() String.format("%-100s", "/ | Divides display value by next input"), String.format("%-100s", "exp | Display value to power of next input"), String.format("%-100s", "sq | Display value multiplied by itself"), - String.format("%-100s", "sqrt | Square root of display value")); + String.format("%-100s", "sqrt | Square root of display value"), + String.format("%-100s", "mode | Cycle mode"), + String.format("%-100s", "bin | Switch to binary"), + String.format("%-100s", "oct | Switch to octal"), + String.format("%-100s", "dec | Switch to decimal"), + String.format("%-100s", "hex | Switch to hex"), + String.format("%-100s", "rad | Use Radians for Trigonometry"), + String.format("%-100s", "sin | Sine of display value"), + String.format("%-100s", "cos | Cosine of display value"), + String.format("%-100s", "tan | Tangent of display value"), + String.format("%-100s", "invsin | Inverse sine of display value"), + String.format("%-100s", "invcos | Inverse cosine of display value"), + String.format("%-100s", "invtan | Inverse tangent of display value"), + String.format("%-100s", "log | Log of display value"), + String.format("%-100s", "invlog | Inverse log of display value"), + String.format("%-100s", "nlog | N-log of display value"), + String.format("%-100s", "invnlog | Inverse N-log of display value"), + String.format("%-100s", "! | Factorial of display value"), + String.format("%-100s", "fib | Fibonacci of display value")); + } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ValidOperations.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ValidOperations.java index 0cb0e65c..d6158c79 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ValidOperations.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ValidOperations.java @@ -26,6 +26,19 @@ public ValidOperations() listOfValid.add("oct"); listOfValid.add("dec"); listOfValid.add("hex"); + listOfValid.add("rad"); + listOfValid.add("log"); + listOfValid.add("invlog"); + listOfValid.add("nlog"); + listOfValid.add("invnlog"); + listOfValid.add("sin"); + listOfValid.add("cos"); + listOfValid.add("tan"); + listOfValid.add("invsin"); + listOfValid.add("invcos"); + listOfValid.add("invtan"); + listOfValid.add("!"); + listOfValid.add("fib"); } public static Boolean isValid(String op) diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/InputErrorHandlerTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/InputErrorHandlerTest.java new file mode 100644 index 00000000..6c8d7358 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/InputErrorHandlerTest.java @@ -0,0 +1,88 @@ +package com.zipcodewilmington.scientificcalculator; + +import jdk.internal.util.xml.impl.Input; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class InputErrorHandlerTest { + @Test + public void TestInputErrorHandlerNumber() + { + Boolean expected = true; + InputErrorHandler TestInputErrorHandler = new InputErrorHandler(); + Boolean actual = TestInputErrorHandler.validNumber("500.505"); + + assertEquals(expected, actual); + } + + @Test + public void TestInputErrorHandlerSecondNumber() + { + Boolean expected = true; + InputErrorHandler TestInputErrorHandler = new InputErrorHandler(); + Boolean actual = TestInputErrorHandler.validNumber("500"); + + assertEquals(expected, actual); + } + + @Test + public void TestInputErrorHandlerAdd() + { + Boolean expected = true; + InputErrorHandler TestInputErrorHandler = new InputErrorHandler(); + Boolean actual = TestInputErrorHandler.validOp("+"); + + assertEquals(expected, actual); + } + + @Test + public void TestInputErrorHandlerWrongAdd() + { + Boolean expected = false; + InputErrorHandler TestInputErrorHandler = new InputErrorHandler(); + Boolean actual = TestInputErrorHandler.validOp("add"); + + assertEquals(expected, actual); + } + + @Test + public void TestInputErrorHandlerSub() + { + Boolean expected = true; + InputErrorHandler TestInputErrorHandler = new InputErrorHandler(); + Boolean actual = TestInputErrorHandler.validOp("-"); + + assertEquals(expected, actual); + } + + @Test + public void TestInputErrorHandlerMode() + { + Boolean expected = true; + InputErrorHandler TestInputErrorHandler = new InputErrorHandler(); + Boolean actual = TestInputErrorHandler.validOp("mode"); + + assertEquals(expected, actual); + } + + @Test + public void TestInputErrorHandlerSqrt() + { + Boolean expected = true; + InputErrorHandler TestInputErrorHandler = new InputErrorHandler(); + Boolean actual = TestInputErrorHandler.validOp("sqrt"); + + assertEquals(expected, actual); + } + + @Test + public void TestInputErrorHandlerFoo() + { + Boolean expected = false; + InputErrorHandler TestInputErrorHandler = new InputErrorHandler(); + Boolean actual = TestInputErrorHandler.validOp("foo"); + + assertEquals(expected, actual); + } +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ValidOperationsTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ValidOperationsTest.java new file mode 100644 index 00000000..a0038ca7 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ValidOperationsTest.java @@ -0,0 +1,47 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class ValidOperationsTest { + @Test + public void TestValidOperationsAdd() + { + Boolean expected = true; + ValidOperations TestValidOperations = new ValidOperations(); + Boolean actual = TestValidOperations.isValid("+"); + + assertEquals(expected, actual); + } + + @Test + public void TestValidOperationsSub() + { + Boolean expected = true; + ValidOperations TestValidOperations = new ValidOperations(); + Boolean actual = TestValidOperations.isValid("-"); + + assertEquals(expected, actual); + } + + @Test + public void TestValidOperationsWrongAdd() + { + Boolean expected = false; + ValidOperations TestValidOperations = new ValidOperations(); + Boolean actual = TestValidOperations.isValid("add"); + + assertEquals(expected, actual); + } + + @Test + public void TestValidOperationsFoo() + { + Boolean expected = false; + ValidOperations TestValidOperations = new ValidOperations(); + Boolean actual = TestValidOperations.isValid("foo"); + + assertEquals(expected, actual); + } +} \ No newline at end of file From 264706df31ea098733458873004181b52e8685b2 Mon Sep 17 00:00:00 2001 From: Zanetta Norris Date: Sun, 9 Feb 2020 14:50:32 -0500 Subject: [PATCH 45/53] Fixed the test cases to evaluate to four decimal places --- .../scientificcalculator/ConversionMath.java | 17 ++++++++- .../scientific_calculator/TestBasicMath.java | 8 ++-- .../TestConversionMath.java | 38 ++++++++++++++++++- 3 files changed, 56 insertions(+), 7 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java index a4947aef..4a6edc42 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java @@ -3,11 +3,26 @@ public class ConversionMath { public static Double feetToMeters (Double numberOne) { - return numberOne / 3.281.0; + return numberOne / 3.2810; } public static Double metersToFeet (Double numberOne) { return numberOne * 3.28084; } + public static Double poundsToKilos(Double numberOne) { + return numberOne / 2.205; + } + public static Double kilosToPounds(Double numberOne) { + return numberOne * 2.205; + } + public static Double fahrenheitToCelsius (Double numberOne) { + return ((numberOne - 32) * 5 / 9); + } + public static Double celsiusToFahrenheit (Double numberOne) { + return ((numberOne * 9 / 5) + 32); + } + } + + diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java index a814b6f3..7a013552 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java @@ -36,7 +36,7 @@ public void TestAdditionDecimal() } // Subtraction test cases @Test - public void TestSubtractionThirtyFifteen() + public void TestSubtractionWholes() { BasicMath subtractionTest = new BasicMath(); Double actual; @@ -75,7 +75,7 @@ public void TestSubtractionGreater() } // Multiplication test cases @Test - public void TestMultiplicationWholes() + public void TestMultiplicationWholes1() { BasicMath multiplicationTest = new BasicMath(); Double actual; @@ -88,10 +88,10 @@ public void TestMultiplicationDecimals() { BasicMath multiplicationTest = new BasicMath(); Double actual; - Double expected = 18.480000000000004; + Double expected = 18.48; // fix this rounding error actual = multiplicationTest.multiplication(8.4,2.2); - assertEquals(expected, actual); + assertEquals(expected, actual, .0001); } // Division Test Cases @Test diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java index e7bd4853..443fdee7 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java @@ -8,12 +8,46 @@ public class TestConversionMath { @Test - public void TestFeetToMetersWhole() - { + public void TestFeetToMetersWhole() { ConversionMath feetToMetersTest = new ConversionMath(); Double actual; Double expected = 0.30478512648582745; actual = feetToMetersTest.feetToMeters(1.0); assertEquals(expected, actual); } + @Test + public void TestFeetToMetersDecimal() { + ConversionMath feetToMetersTest = new ConversionMath(); + Double actual; + Double expected = 0.762; + actual = feetToMetersTest.feetToMeters(2.5); + assertEquals(expected, actual); + } + + @Test + public void TestCtoF() { + ConversionMath celsiusToFahrenheitTest = new ConversionMath(); + Double actual; + Double expected = 140.0; + actual = celsiusToFahrenheitTest.celsiusToFahrenheit(60.0); + assertEquals(expected, actual); + } + + @Test + public void TestFtoC() { + ConversionMath fahrenheitToCelsiusTest = new ConversionMath(); + Double actual; + Double expected = 60.0; + actual = fahrenheitToCelsiusTest.fahrenheitToCelsius(140.0); + assertEquals(expected, actual); + } + + @Test + public void TestFtoCDecimal() { + ConversionMath fahrenheitToCelsiusTest = new ConversionMath(); + Double actual; + Double expected = 37.77777777777778; + actual = fahrenheitToCelsiusTest.fahrenheitToCelsius(100.0); + assertEquals(expected, actual); + } } From bf9d64a7dfa3de831ad50060129695ae56526534 Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 14:57:23 -0500 Subject: [PATCH 46/53] Pulling from dev --- .../InputErrorHandler.java | 8 +----- .../scientificcalculator/MainApplication.java | 7 ++++- .../scientificcalculator/Operation.java | 28 +++++++++++++++++++ 3 files changed, 35 insertions(+), 8 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java b/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java index 3cd23bcd..a0994e83 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java @@ -43,12 +43,6 @@ public static Boolean validNumber(String in) isANumber = false; } - if (isANumber) - { - return true; - } else - { - return false; - } + return isANumber; } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 1df4bb4b..90c225ed 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -35,7 +35,12 @@ else if(InputErrorHandler.validNumber(userInput)) } else if(InputErrorHandler.validOp(userInput)) { - + String currentOperation = userInput; + if(Operation.isUnary(currentOperation)) + { + display.setDisplay(Operation.perform(currentOperation, display.getDisplay())); + } + // display.setDisplay(Operation.perform(currentOperation, display.getDisplay(), secondInput)); } // If number, change display value // Is it menu? List menu diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java new file mode 100644 index 00000000..49b6968b --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java @@ -0,0 +1,28 @@ +package com.zipcodewilmington.scientificcalculator; + +public class Operation { + + public Operation() { + } + + public static Double perform(String op, Double... value) { + Double calculation = 0.0; + + if ("+".equals(op)) { + calculation = BasicMath.addition(value[0], value[1]); + } else if ("-".equals(op)) { + calculation = BasicMath.addition(value[0], value[1]); + } else if ("*".equals(op)) { + calculation = BasicMath.addition(value[0], value[1]); + } else if ("/".equals(op)) { + calculation = BasicMath.addition(value[0], value[1]); + } + + return calculation; + } + + public static Boolean isUnary(String currentOperation) + { + // if(currentOperation == "c" || currentOperation == "m") + } +} \ No newline at end of file From 5653206493d7ba6f2783a405b88d424e79ce47b5 Mon Sep 17 00:00:00 2001 From: Zanetta Norris Date: Sun, 9 Feb 2020 16:44:02 -0500 Subject: [PATCH 47/53] BasicMath and Conversion Math methods and tests complete. All tests pass. --- .../scientificcalculator/BasicMath.java | 2 +- .../scientific_calculator/TestBasicMath.java | 21 +++++++- .../TestConversionMath.java | 54 ++++++++++++++++--- 3 files changed, 69 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java index 2673b68d..a955c769 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java @@ -12,7 +12,7 @@ public static Double multiplication (Double numberOne, Double numberTwo) { return numberOne * numberTwo; } public static Double division (Double numberOne, Double numberTwo) { - return numberOne / numberTwo; + return numberOne / numberTwo; } public static Double exponent (Double numberOne, Double numberTwo){ return Math.pow(numberOne, numberTwo); diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java index 7a013552..4f55abf4 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestBasicMath.java @@ -1,6 +1,7 @@ package com.zipcodewilmington.scientific_calculator; import com.zipcodewilmington.scientificcalculator.BasicMath; +import jdk.nashorn.internal.objects.Global; import org.junit.Test; import static org.junit.Assert.assertEquals; @@ -110,9 +111,18 @@ public void TestDivisionDecimals() Double actual; Double expected = 6.2; actual = divisionTest.division(12.4,2.0); - assertEquals(expected, actual); + assertEquals(expected, actual, .0001); + } @Test + public void TestDivisionZero() { + BasicMath divisionTest = new BasicMath(); + Double actual; + Double expected = Global.Infinity; + actual = divisionTest.division(12.4, 0.0); + assertEquals(expected, actual, .0001); + } + @Test public void TestExponentSixTwo() { BasicMath exponentTest = new BasicMath(); @@ -149,5 +159,14 @@ public void TestSquareRootFour() actual = squarerootTest.squareroot(4.0); assertEquals(expected, actual); } + @Test + public void TestSquareRootNegative() + { + BasicMath squarerootTest = new BasicMath(); + Double actual; + Double expected = Double.NaN; + actual = squarerootTest.squareroot(-4.0); + assertEquals(expected, actual); + } } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java index 443fdee7..e843dc0f 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestConversionMath.java @@ -13,7 +13,7 @@ public void TestFeetToMetersWhole() { Double actual; Double expected = 0.30478512648582745; actual = feetToMetersTest.feetToMeters(1.0); - assertEquals(expected, actual); + assertEquals(expected, actual, 0.001); } @Test public void TestFeetToMetersDecimal() { @@ -21,7 +21,7 @@ public void TestFeetToMetersDecimal() { Double actual; Double expected = 0.762; actual = feetToMetersTest.feetToMeters(2.5); - assertEquals(expected, actual); + assertEquals(expected, actual, 0.001); } @Test @@ -30,7 +30,15 @@ public void TestCtoF() { Double actual; Double expected = 140.0; actual = celsiusToFahrenheitTest.celsiusToFahrenheit(60.0); - assertEquals(expected, actual); + assertEquals(expected, actual, 0.001); + } + @Test + public void TestCtoFDecimal() { + ConversionMath celsiusToFahrenheitTest = new ConversionMath(); + Double actual; + Double expected = 107.6; + actual = celsiusToFahrenheitTest.celsiusToFahrenheit(42.0); + assertEquals(expected, actual, 0.001); } @Test @@ -39,15 +47,49 @@ public void TestFtoC() { Double actual; Double expected = 60.0; actual = fahrenheitToCelsiusTest.fahrenheitToCelsius(140.0); - assertEquals(expected, actual); + assertEquals(expected, actual, 0.001); } @Test public void TestFtoCDecimal() { ConversionMath fahrenheitToCelsiusTest = new ConversionMath(); Double actual; - Double expected = 37.77777777777778; + Double expected = 37.778; actual = fahrenheitToCelsiusTest.fahrenheitToCelsius(100.0); - assertEquals(expected, actual); + assertEquals(expected, actual, 0.001); + } + + @Test + public void TestPoundstoKilos() { + ConversionMath poundsToKilosTest = new ConversionMath(); + Double actual; + Double expected = 5.44311; + actual = poundsToKilosTest.poundsToKilos(12.0); + assertEquals(expected, actual, 0.001); + } + + @Test + public void TestPoundstoKilosDecimal() { + ConversionMath poundsToKilosTest = new ConversionMath(); + Double actual; + Double expected = 7.9365; + actual = poundsToKilosTest.poundsToKilos(17.5); + assertEquals(expected, actual, 0.001); + } + @Test + public void TestKilosToPounds() { + ConversionMath kilosToPoundsTest= new ConversionMath(); + Double actual; + Double expected = 81.585; + actual = kilosToPoundsTest.kilosToPounds(37.0); + assertEquals(expected, actual, 0.001); + } + @Test + public void TestKilosToPoundsDecimal() { + ConversionMath kilosToPoundsTest= new ConversionMath(); + Double actual; + Double expected = 26.901; + actual = kilosToPoundsTest.kilosToPounds(12.2); + assertEquals(expected, actual, 0.001); } } From cefdf7ce176ba5e7f61d39286ecf51ed3c68c43a Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 17:11:12 -0500 Subject: [PATCH 48/53] Need to fix modes --- .../scientificcalculator/BasicMath.java | 7 +- .../scientificcalculator/Display.java | 6 +- .../InputErrorHandler.java | 38 +++++----- .../scientificcalculator/MainApplication.java | 39 +--------- .../scientificcalculator/Menu.java | 9 +-- .../scientificcalculator/Operation.java | 34 ++++----- .../scientificcalculator/Prompt.java | 76 ++++++++++++------- .../InputErrorHandlerTest.java | 10 +++ .../ValidOperationsTest.java | 8 ++ 9 files changed, 113 insertions(+), 114 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java index 2673b68d..e3fc9886 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java @@ -25,12 +25,7 @@ public static Double square (Double numberOne) { public static Double squareroot (Double numberOne){ return (Math.sqrt(numberOne)); } - public static Double inverse(Double numberOne){ - return 1/numberOne; - } - - - } +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 6e01a0ce..a2f3f14c 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -71,11 +71,12 @@ public String update() radianLine = " "; } + + // This needs to be fixed if(mode == Modes.BINARY) { baseLine = String.format("%-46s", "BIN"); - valueLine = Integer.toBinaryString(currentValue.intValue()) + " "; - currentValue = Double.parseDouble(valueLine); + valueLine = Integer.toBinaryString(currentValue.intValue()) + " ";currentValue = Double.parseDouble(valueLine); } else if(mode == Modes.OCTAL) { @@ -142,7 +143,6 @@ public void clear() { error = false; isRadians = false; mode = Modes.DEC; - update(); // Send a command to input to remove last operation and last value input } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java b/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java index a0994e83..62af981d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java @@ -8,23 +8,6 @@ public class InputErrorHandler { public InputErrorHandler() { - listOfValid.add("c"); - listOfValid.add("m+"); - listOfValid.add("m"); - listOfValid.add("mc"); - listOfValid.add("inv"); - listOfValid.add("+"); - listOfValid.add("-"); - listOfValid.add("*"); - listOfValid.add("/"); - listOfValid.add("exp"); - listOfValid.add("sq"); - listOfValid.add("sqrt"); - listOfValid.add("mode"); - listOfValid.add("bin"); - listOfValid.add("oct"); - listOfValid.add("dec"); - listOfValid.add("hex"); } public static Boolean validOp(String op) @@ -45,4 +28,25 @@ public static Boolean validNumber(String in) return isANumber; } + + static { + listOfValid.add("c"); // + listOfValid.add("m+"); // + listOfValid.add("m"); // + listOfValid.add("mc"); // + listOfValid.add("inv"); // + listOfValid.add("+"); + listOfValid.add("-"); + listOfValid.add("*"); + listOfValid.add("/"); + listOfValid.add("exp"); + listOfValid.add("sq"); // + listOfValid.add("sqrt"); // + listOfValid.add("mode"); // + listOfValid.add("bin"); // + listOfValid.add("oct"); // + listOfValid.add("dec"); // + listOfValid.add("hex"); // + listOfValid.add("rad"); // + } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 90c225ed..40dba370 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -5,46 +5,13 @@ * James, Sandy and Zanetta version */ public class MainApplication { + private static Prompt prompt = new Prompt(); + public static void main(String[] args) { Console.println("Welcome to Mr. Math!"); Console.println("To see a valid list of commands, type 'menu' at any time"); Console.println("When you are finish with Mr. Math, feel free to quit by entering ':q'"); - // 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); - - Display display = new Display(); - Prompt user = new Prompt(); - String userInput = ""; - - do { - display.update(); - userInput = Console.getStringInput(" "); - if (userInput.equals("menu")) - { - Console.print(Menu.callMenu()); - } - else if(InputErrorHandler.validNumber(userInput)) - { - display.setDisplay(Double.parseDouble(userInput)); - } - else if(InputErrorHandler.validOp(userInput)) - { - String currentOperation = userInput; - if(Operation.isUnary(currentOperation)) - { - display.setDisplay(Operation.perform(currentOperation, display.getDisplay())); - } - // display.setDisplay(Operation.perform(currentOperation, display.getDisplay(), secondInput)); - } - // If number, change display value - // Is it menu? List menu - // Call actual operations - } while(!userInput.equals(":q")); + prompt.start(); } } \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java index 950bcdbe..1b1ca54d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java @@ -11,8 +11,8 @@ public static String callMenu() return menuBox.draw( String.format("%-100s", "c | Resets the display to 0"), - String.format("%-100s", "m | Store display to memory"), - String.format("%-100s", "m+ | Recall stored memory as user input"), + String.format("%-100s", "m | Remember display"), + String.format("%-100s", "m+ | Store memory"), String.format("%-100s", "mc | Reset memory to 0"), String.format("%-100s", "inv | Invert the sign of the display value"), String.format("%-100s", "bin | Set mode to binary"), @@ -27,11 +27,6 @@ public static String callMenu() String.format("%-100s", "exp | Display value to power of next input"), String.format("%-100s", "sq | Display value multiplied by itself"), String.format("%-100s", "sqrt | Square root of display value"), - String.format("%-100s", "mode | Cycle mode"), - String.format("%-100s", "bin | Switch to binary"), - String.format("%-100s", "oct | Switch to octal"), - String.format("%-100s", "dec | Switch to decimal"), - String.format("%-100s", "hex | Switch to hex"), String.format("%-100s", "rad | Use Radians for Trigonometry"), String.format("%-100s", "sin | Sine of display value"), String.format("%-100s", "cos | Cosine of display value"), diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java index 49b6968b..d8bad9ed 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java @@ -1,28 +1,24 @@ package com.zipcodewilmington.scientificcalculator; public class Operation { - - public Operation() { - } - - public static Double perform(String op, Double... value) { - Double calculation = 0.0; - - if ("+".equals(op)) { - calculation = BasicMath.addition(value[0], value[1]); - } else if ("-".equals(op)) { - calculation = BasicMath.addition(value[0], value[1]); - } else if ("*".equals(op)) { - calculation = BasicMath.addition(value[0], value[1]); - } else if ("/".equals(op)) { - calculation = BasicMath.addition(value[0], value[1]); + public static Boolean isSetting(String op) { + if ("c".equals(op) || "m".equals(op) || "m+".equals(op) || + "mc".equals(op) || "rad".equals(op)) { + return true; + } else { + return false; } - - return calculation; } - public static Boolean isUnary(String currentOperation) + public static Boolean isUnary(String op) { - // if(currentOperation == "c" || currentOperation == "m") + if ("inv".equals(op) || "bin".equals(op) || "oct".equals(op) || "dec".equals(op) || "hex".equals(op) || + "mode".equals(op) || "sq".equals(op) || "sqrt".equals(op) || "sin".equals(op) || "cos".equals(op) || + "tan".equals(op) || "invsin".equals(op) || "invcos".equals(op) || "invtan".equals(op) || "log".equals(op) || + "nlog".equals(op) || "invlog".equals(op) || "invnlog".equals(op) || "!".equals(op) || "fib".equals(op)) { + return true; + } else { + return false; + } } } \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java index 17943151..a6c08d35 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java @@ -5,7 +5,8 @@ public class Prompt { private String previousOperation; private Double inputValue; private String message; - + private Display display = new Display(); + private Memory memory = new Memory(); public Prompt() { @@ -15,43 +16,66 @@ public Prompt() message = ""; } - public String getMessage() - { - return message; - } - public Double getInputValue(Double val) - { - return inputValue; + public void start() { + display.update(); + parseInput(Console.getStringInput("> ")); } - public void input(String in, Double displayValue) + public void parseInput(String s) { - Boolean isANumber = true; - try + if(InputErrorHandler.validNumber(s)) { - Double num = Double.parseDouble(in); - } - catch (NumberFormatException error) + display.setDisplay(Double.parseDouble(s)); + } else if(s.equalsIgnoreCase("menu")) { - isANumber = false; - } - - if(isANumber) + Console.println(Menu.callMenu()); + } else if(!InputErrorHandler.validOp(s)) { - inputValue = Double.parseDouble(in); + Console.println("Invalid input, 'menu' will list commands"); + } else if(Operation.isSetting(s)) { + if (s.equalsIgnoreCase("c")) { + display.clear(); + } else if (s.equalsIgnoreCase("m")) { + display.setDisplay(memory.getMemory()); + } else if (s.equalsIgnoreCase("m+")) { + memory.setMemory(display.getDisplay()); + } else if (s.equalsIgnoreCase("mc")) { + memory.setMemory(0.0); + } else if (s.equalsIgnoreCase("rad")) { + display.toggleRadians(); + } } - else + + else if(Operation.isUnary(s)) { - if(ValidOperations.isValid(in)) + if(s.equalsIgnoreCase("inv")) { - previousOperation = inputOperation; - inputOperation = in; - } - else // Throw error + display.invSign(); + } else if(s.equalsIgnoreCase("sq")) + { + display.setDisplay(BasicMath.square(display.getDisplay())); + } else if(s.equalsIgnoreCase("sqrt")) + { + display.setDisplay(BasicMath.squareroot(display.getDisplay())); + } else if(s.equalsIgnoreCase("mode")) { - message = "Invalid user input"; + display.setMode(); + } else if(s.equalsIgnoreCase("bin")) + { + display.setMode(Display.Modes.BINARY); + } else if(s.equalsIgnoreCase("oct")) + { + display.setMode(Display.Modes.OCTAL); + } else if(s.equalsIgnoreCase("dec")) + { + display.setMode(Display.Modes.DEC); + } else if(s.equalsIgnoreCase("hex")) { + display.setMode(Display.Modes.HEX); } } + + display.update(); + parseInput(Console.getStringInput("> ")); } } diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/InputErrorHandlerTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/InputErrorHandlerTest.java index 6c8d7358..1faa9815 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/InputErrorHandlerTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/InputErrorHandlerTest.java @@ -85,4 +85,14 @@ public void TestInputErrorHandlerFoo() assertEquals(expected, actual); } + + @Test + public void TestInputErrorHandlerClear() + { + Boolean expected = true; + InputErrorHandler TestInputErrorHandler = new InputErrorHandler(); + Boolean actual = TestInputErrorHandler.validOp("c"); + + assertEquals(expected, actual); + } } \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/ValidOperationsTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/ValidOperationsTest.java index a0038ca7..de9d9c88 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/ValidOperationsTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/ValidOperationsTest.java @@ -44,4 +44,12 @@ public void TestValidOperationsFoo() assertEquals(expected, actual); } + + @Test + public void TestClear() + { + Boolean expected = true; + ValidOperations TestValidOperations = new ValidOperations(); + Boolean actual = TestValidOperations.isValid("c"); + } } \ No newline at end of file From 82b5d36c7f099cd83515eacafb14187fe330681c Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 17:23:52 -0500 Subject: [PATCH 49/53] Merge trouble --- .../scientificcalculator/BasicMath.java | 3 +++ .../scientificcalculator/Display.java | 8 +++----- .../scientificcalculator/DisplayTest.java | 12 +++++++++++- 3 files changed, 17 insertions(+), 6 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java index e3fc9886..4944e91f 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/BasicMath.java @@ -25,6 +25,9 @@ public static Double square (Double numberOne) { public static Double squareroot (Double numberOne){ return (Math.sqrt(numberOne)); } + public static Double inverse(Double numberOne){ + return 1/numberOne; + } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index a2f3f14c..237c92cb 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -76,13 +76,12 @@ public String update() if(mode == Modes.BINARY) { baseLine = String.format("%-46s", "BIN"); - valueLine = Integer.toBinaryString(currentValue.intValue()) + " ";currentValue = Double.parseDouble(valueLine); + valueLine = Integer.toBinaryString(currentValue.intValue()) + " "; } else if(mode == Modes.OCTAL) { baseLine = String.format("%-46s", "OCTAL"); valueLine = Integer.toOctalString(currentValue.intValue()) + " "; - currentValue = Double.parseDouble(valueLine); } else if(mode == Modes.DEC) { @@ -99,7 +98,6 @@ else if(mode == Modes.HEX) { baseLine = String.format("%-46s", "HEX"); valueLine = Integer.toHexString(currentValue.intValue()) + " "; - currentValue = Double.parseDouble(valueLine); } output = displayBox.draw(radianLine, valueLine, baseLine); @@ -146,9 +144,9 @@ public void clear() { // Send a command to input to remove last operation and last value input } - public Double invSign() + public void invSign() { - return currentValue * -1.0; + currentValue *= -1.0; } public Double absoluteValue() diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java index 8df91d88..39712e0d 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/DisplayTest.java @@ -75,7 +75,7 @@ public void TestClear() { assertEquals(expected, actual); } - @Test +/* @Test public void TestInvSign() { Double expected = -47.6; Display TestDisplay = new Display(); @@ -85,6 +85,16 @@ public void TestInvSign() { assertEquals(expected, actual); } + @Test + public void TestInvSignAgain() { + Double expected = 105.9; + Display TestDisplay = new Display(); + TestDisplay.setDisplay(-105.9); + Double actual = TestDisplay.invSign(); + + assertEquals(expected, actual); + } */ + @Test public void TestAbsoluteValueOfTen() { From 58984071dba801608bd5c5813f02e4ea6d77b48a Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 17:57:23 -0500 Subject: [PATCH 50/53] More cases --- .../scientificcalculator/ConversionMath.java | 3 +- .../InputErrorHandler.java | 12 ++++ .../scientificcalculator/OtherFunctions.java | 10 ++-- .../scientificcalculator/Prompt.java | 28 +++++++++ .../TestOtherFunctions.java | 60 +++++++++---------- 5 files changed, 76 insertions(+), 37 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java index 4a6edc42..225c6ef9 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ConversionMath.java @@ -5,7 +5,6 @@ public class ConversionMath { public static Double feetToMeters (Double numberOne) { return numberOne / 3.2810; } - public static Double metersToFeet (Double numberOne) { return numberOne * 3.28084; } @@ -18,7 +17,7 @@ public static Double kilosToPounds(Double numberOne) { public static Double fahrenheitToCelsius (Double numberOne) { return ((numberOne - 32) * 5 / 9); } - public static Double celsiusToFahrenheit (Double numberOne) { + public static Double celsiusToFahrenheit (Double numberOne) { return ((numberOne * 9 / 5) + 32); } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java b/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java index 62af981d..b7e70e33 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/InputErrorHandler.java @@ -48,5 +48,17 @@ public static Boolean validNumber(String in) listOfValid.add("dec"); // listOfValid.add("hex"); // listOfValid.add("rad"); // + listOfValid.add("log"); + listOfValid.add("invlog"); + listOfValid.add("nlog"); + listOfValid.add("invnlog"); + listOfValid.add("!"); + listOfValid.add("fib"); + listOfValid.add("mtf"); + listOfValid.add("ftm"); + listOfValid.add("ptk"); + listOfValid.add("ktp"); + listOfValid.add("ftc"); + listOfValid.add("ctf"); } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/OtherFunctions.java b/src/main/java/com/zipcodewilmington/scientificcalculator/OtherFunctions.java index 7200921d..836fc753 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/OtherFunctions.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/OtherFunctions.java @@ -10,21 +10,21 @@ public OtherFunctions() { x = 0.0; } - public static int Fact(int x){ + public static Double Fact(Double x){ if (x<0) - return 0; + return 0.0; if (x == 0 || x == 1) - return 1; + return 1.0; return x*Fact(x-1); } - public static int Fibon(int x) { + public static Double Fibon(Double x) { if (x<0) - return 0; + return 0.0; if (0<=x && x<=1) return x; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java index a6c08d35..9f497cdd 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java @@ -1,5 +1,9 @@ package com.zipcodewilmington.scientificcalculator; +import sun.rmi.runtime.Log; + +import javax.print.attribute.standard.MediaSize; + public class Prompt { private String inputOperation; private String previousOperation; @@ -72,6 +76,30 @@ else if(Operation.isUnary(s)) display.setMode(Display.Modes.DEC); } else if(s.equalsIgnoreCase("hex")) { display.setMode(Display.Modes.HEX); + } else if(s.equalsIgnoreCase("log")) { + display.setDisplay(Logarithm.Log(display.getDisplay())); + } else if(s.equalsIgnoreCase("invlog")) { + display.setDisplay(Logarithm.InvLog(display.getDisplay())); + } else if(s.equalsIgnoreCase("nlog")) { + display.setDisplay(Logarithm.NLog(display.getDisplay())); + } else if(s.equalsIgnoreCase("invnlog")) { + display.setDisplay(Logarithm.InvNLog(display.getDisplay())); + } else if(s.equalsIgnoreCase("!")) { + display.setDisplay(OtherFunctions.Fact(display.getDisplay())); + } else if(s.equalsIgnoreCase("fib")) { + display.setDisplay(OtherFunctions.Fibon(display.getDisplay())); + } else if(s.equalsIgnoreCase("ftm")) { + display.setDisplay(ConversionMath.feetToMeters(display.getDisplay())); + } else if(s.equalsIgnoreCase("mtf")) { + display.setDisplay(ConversionMath.metersToFeet(display.getDisplay())); + } else if(s.equalsIgnoreCase("ptk")) { + display.setDisplay(ConversionMath.poundsToKilos(display.getDisplay())); + } else if(s.equalsIgnoreCase("ktp")) { + display.setDisplay(ConversionMath.kilosToPounds(display.getDisplay())); + } else if(s.equalsIgnoreCase("ctf")) { + display.setDisplay(ConversionMath.celsiusToFahrenheit(display.getDisplay())); + } else if(s.equalsIgnoreCase("ftc")) { + display.setDisplay(ConversionMath.fahrenheitToCelsius(display.getDisplay())); } } diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/TestOtherFunctions.java b/src/test/java/com/zipcodewilmington/scientificcalculator/TestOtherFunctions.java index 1a05820d..b41efe5d 100644 --- a/src/test/java/com/zipcodewilmington/scientificcalculator/TestOtherFunctions.java +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/TestOtherFunctions.java @@ -11,9 +11,9 @@ public class TestOtherFunctions { public void FactNegativeOne() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected=0; - actual= OtherFunctions.Fact(-1); + Double actual; + Double expected=0.0; + actual= OtherFunctions.Fact(-1.0); assertEquals(expected,actual); } @@ -22,9 +22,9 @@ public void FactNegativeOne() { public void FactZero() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected=1; - actual= OtherFunctions.Fact(1); + Double actual; + Double expected= 1.0; + actual = OtherFunctions.Fact(1.0); assertEquals(expected,actual); } @@ -33,9 +33,9 @@ public void FactZero() { public void FactOne() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected=1; - actual= OtherFunctions.Fact(1); + Double actual; + Double expected=1.0; + actual= OtherFunctions.Fact(1.0); assertEquals(expected,actual); } @@ -44,9 +44,9 @@ public void FactOne() { public void FactFive() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected=120; - actual= OtherFunctions.Fact(5); + Double actual; + Double expected=120.0; + actual= OtherFunctions.Fact(5.0); assertEquals(expected,actual); } @@ -57,9 +57,9 @@ public void FactFive() { public void FibonNegativeOne() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected = 0; - actual = OtherFunctions.Fibon(-1); + Double actual; + Double expected = 0.0; + actual = OtherFunctions.Fibon(-1.0); assertEquals(expected, actual); } @@ -68,9 +68,9 @@ public void FibonNegativeOne() { public void FibonZero() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected=0; - actual= OtherFunctions.Fibon(0); + Double actual; + Double expected=0.0; + actual= OtherFunctions.Fibon(0.0); assertEquals(expected,actual); } @@ -79,9 +79,9 @@ public void FibonZero() { public void FibonOne() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected=1; - actual= OtherFunctions.Fibon(1); + Double actual; + Double expected=1.0; + actual= OtherFunctions.Fibon(1.0); assertEquals(expected,actual); } @@ -90,9 +90,9 @@ public void FibonOne() { public void FibonTwo() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected=1; - actual= OtherFunctions.Fibon(2); + Double actual; + Double expected=1.0; + actual= OtherFunctions.Fibon(2.0); assertEquals(expected,actual); } @@ -101,9 +101,9 @@ public void FibonTwo() { public void FibonThree() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected=2; - actual= OtherFunctions.Fibon(3); + Double actual; + Double expected=2.0; + actual= OtherFunctions.Fibon(3.0); assertEquals(expected,actual); } @@ -112,9 +112,9 @@ public void FibonThree() { public void FibonTen() { OtherFunctions OtherFunctionsTest = new OtherFunctions(); - int actual; - int expected=55; - actual= OtherFunctions.Fibon(10); + Double actual; + Double expected=55.0; + actual= OtherFunctions.Fibon(10.0); assertEquals(expected,actual); } From 9a29de1e75c8c6b4863faabb687fb400ea179c3b Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 18:33:24 -0500 Subject: [PATCH 51/53] Lots of bugs --- .../scientificcalculator/Display.java | 73 ++++++-------- .../scientificcalculator/Operation.java | 11 +++ .../scientificcalculator/Prompt.java | 99 +++++++++++-------- 3 files changed, 98 insertions(+), 85 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 237c92cb..d85ce2be 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -46,58 +46,43 @@ public void setDisplayWidth(int newWidth) displayWidth = newWidth; } - public String update() - { - String output; + public String update() { + String output = ""; String radianLine = ""; String valueLine = ""; String baseLine = ""; - if(error) - { + if (error) { radianLine = String.format("%-46s", "ERR"); valueLine = "ERR "; - baseLine = String.format("%-46s","ERR"); + baseLine = String.format("%-46s", "ERR"); output = displayBox.draw(radianLine, valueLine, baseLine); - return output; - } - - if(isRadians == true) - { - radianLine = String.format("%-46s", "RAD"); - } - else - { - radianLine = " "; - } + } else { + if (isRadians == true) { + radianLine = String.format("%-46s", "RAD"); + } else { + radianLine = " "; + } - // This needs to be fixed - if(mode == Modes.BINARY) - { - baseLine = String.format("%-46s", "BIN"); - valueLine = Integer.toBinaryString(currentValue.intValue()) + " "; - } - else if(mode == Modes.OCTAL) - { - baseLine = String.format("%-46s", "OCTAL"); - valueLine = Integer.toOctalString(currentValue.intValue()) + " "; - } - else if(mode == Modes.DEC) - { - if(currentValue % 1 == 0) // No decimal - { - valueLine = Integer.toString(currentValue.intValue()) + " "; + // This needs to be fixed + if (mode == Modes.BINARY) { + baseLine = String.format("%-46s", "BIN"); + valueLine = Integer.toBinaryString(currentValue.intValue()) + " "; + } else if (mode == Modes.OCTAL) { + baseLine = String.format("%-46s", "OCTAL"); + valueLine = Integer.toOctalString(currentValue.intValue()) + " "; + } else if (mode == Modes.DEC) { + if (currentValue % 1 == 0) // No decimal + { + valueLine = Integer.toString(currentValue.intValue()) + " "; + } else { + valueLine = Double.toString(currentValue) + " "; + } + } else if (mode == Modes.HEX) { + baseLine = String.format("%-46s", "HEX"); + valueLine = Integer.toHexString(currentValue.intValue()) + " "; } - else - { - valueLine = Double.toString(currentValue) + " "; - } - } - else if(mode == Modes.HEX) - { - baseLine = String.format("%-46s", "HEX"); - valueLine = Integer.toHexString(currentValue.intValue()) + " "; } output = displayBox.draw(radianLine, valueLine, baseLine); @@ -171,5 +156,9 @@ public Boolean getIsRadians() return isRadians; } + public Boolean getErr() { + return error; + } + // Make a toggle to switch from normal notation to scientific notation } \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java index d8bad9ed..f5382422 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java @@ -21,4 +21,15 @@ public static Boolean isUnary(String op) return false; } } + + public static Boolean isBinary(String op) + { + if("+".equalsIgnoreCase(op) || "-".equalsIgnoreCase(op) || "*".equalsIgnoreCase(op) || + "/".equalsIgnoreCase(op) || "exp".equalsIgnoreCase(op)) { + return true; + } + else { + return false; + } + } } \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java index 9f497cdd..df667790 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java @@ -12,8 +12,7 @@ public class Prompt { private Display display = new Display(); private Memory memory = new Memory(); - public Prompt() - { + public Prompt() { inputOperation = ""; previousOperation = ""; inputValue = 0.0; @@ -25,19 +24,15 @@ public void start() { parseInput(Console.getStringInput("> ")); } - public void parseInput(String s) - { + public void parseInput(String s) { - if(InputErrorHandler.validNumber(s)) - { + if (InputErrorHandler.validNumber(s)) { display.setDisplay(Double.parseDouble(s)); - } else if(s.equalsIgnoreCase("menu")) - { + } else if (s.equalsIgnoreCase("menu")) { Console.println(Menu.callMenu()); - } else if(!InputErrorHandler.validOp(s)) - { + } else if (!InputErrorHandler.validOp(s)) { Console.println("Invalid input, 'menu' will list commands"); - } else if(Operation.isSetting(s)) { + } else if (Operation.isSetting(s)) { if (s.equalsIgnoreCase("c")) { display.clear(); } else if (s.equalsIgnoreCase("m")) { @@ -49,61 +44,79 @@ public void parseInput(String s) } else if (s.equalsIgnoreCase("rad")) { display.toggleRadians(); } - } - - else if(Operation.isUnary(s)) - { - if(s.equalsIgnoreCase("inv")) - { + } else if (Operation.isUnary(s)) { + if (s.equalsIgnoreCase("inv")) { display.invSign(); - } else if(s.equalsIgnoreCase("sq")) - { + } else if (s.equalsIgnoreCase("sq")) { display.setDisplay(BasicMath.square(display.getDisplay())); - } else if(s.equalsIgnoreCase("sqrt")) - { + } else if (s.equalsIgnoreCase("sqrt")) { display.setDisplay(BasicMath.squareroot(display.getDisplay())); - } else if(s.equalsIgnoreCase("mode")) - { + } else if (s.equalsIgnoreCase("mode")) { display.setMode(); - } else if(s.equalsIgnoreCase("bin")) - { + } else if (s.equalsIgnoreCase("bin")) { display.setMode(Display.Modes.BINARY); - } else if(s.equalsIgnoreCase("oct")) - { + } else if (s.equalsIgnoreCase("oct")) { display.setMode(Display.Modes.OCTAL); - } else if(s.equalsIgnoreCase("dec")) - { + } else if (s.equalsIgnoreCase("dec")) { display.setMode(Display.Modes.DEC); - } else if(s.equalsIgnoreCase("hex")) { + } else if (s.equalsIgnoreCase("hex")) { display.setMode(Display.Modes.HEX); - } else if(s.equalsIgnoreCase("log")) { + } else if (s.equalsIgnoreCase("log")) { display.setDisplay(Logarithm.Log(display.getDisplay())); - } else if(s.equalsIgnoreCase("invlog")) { + } else if (s.equalsIgnoreCase("invlog")) { display.setDisplay(Logarithm.InvLog(display.getDisplay())); - } else if(s.equalsIgnoreCase("nlog")) { + } else if (s.equalsIgnoreCase("nlog")) { display.setDisplay(Logarithm.NLog(display.getDisplay())); - } else if(s.equalsIgnoreCase("invnlog")) { + } else if (s.equalsIgnoreCase("invnlog")) { display.setDisplay(Logarithm.InvNLog(display.getDisplay())); - } else if(s.equalsIgnoreCase("!")) { + } else if (s.equalsIgnoreCase("!")) { display.setDisplay(OtherFunctions.Fact(display.getDisplay())); - } else if(s.equalsIgnoreCase("fib")) { + } else if (s.equalsIgnoreCase("fib")) { display.setDisplay(OtherFunctions.Fibon(display.getDisplay())); - } else if(s.equalsIgnoreCase("ftm")) { + } else if (s.equalsIgnoreCase("ftm")) { display.setDisplay(ConversionMath.feetToMeters(display.getDisplay())); - } else if(s.equalsIgnoreCase("mtf")) { + } else if (s.equalsIgnoreCase("mtf")) { display.setDisplay(ConversionMath.metersToFeet(display.getDisplay())); - } else if(s.equalsIgnoreCase("ptk")) { + } else if (s.equalsIgnoreCase("ptk")) { display.setDisplay(ConversionMath.poundsToKilos(display.getDisplay())); - } else if(s.equalsIgnoreCase("ktp")) { + } else if (s.equalsIgnoreCase("ktp")) { display.setDisplay(ConversionMath.kilosToPounds(display.getDisplay())); - } else if(s.equalsIgnoreCase("ctf")) { + } else if (s.equalsIgnoreCase("ctf")) { display.setDisplay(ConversionMath.celsiusToFahrenheit(display.getDisplay())); - } else if(s.equalsIgnoreCase("ftc")) { + } else if (s.equalsIgnoreCase("ftc")) { display.setDisplay(ConversionMath.fahrenheitToCelsius(display.getDisplay())); } + } else { + Boolean success = true; + Double secondValue = 0.0; + try + { + secondValue = Console.getDoubleInput("Enter a second value: "); + } + catch(NumberFormatException error) + { + success = false; + Console.println("Invalid input"); + } + + if(s.equalsIgnoreCase("+")) { + display.setDisplay(BasicMath.addition(display.getDisplay(), secondValue)); + } else if(s.equalsIgnoreCase("-")) + { + display.setDisplay(BasicMath.subtraction(display.getDisplay(), secondValue)); + } else if(s.equalsIgnoreCase("*")) + { + display.setDisplay(BasicMath.multiplication(display.getDisplay(), secondValue)); + } else if(s.equalsIgnoreCase("/")) + { + display.setDisplay(BasicMath.division(display.getDisplay(), secondValue)); + } else if(s.equalsIgnoreCase("exp")) + { + display.setDisplay(BasicMath.exponent(display.getDisplay(), secondValue)); + } } display.update(); - parseInput(Console.getStringInput("> ")); + parseInput(Console.getStringInput("> ")); } } From 74b85fb89313c6925183abf9ca9670ff72bb945b Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 18:58:30 -0500 Subject: [PATCH 52/53] Fixed conversion --- .../scientificcalculator/Operation.java | 9 ++- .../scientificcalculator/Prompt.java | 3 +- .../scientificcalculator/MenuTest.java | 9 +++ .../scientificcalculator/OperationTest.java | 68 +++++++++++++++++++ .../scientificcalculator/PromptTest.java | 7 ++ 5 files changed, 91 insertions(+), 5 deletions(-) create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/MenuTest.java create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/OperationTest.java create mode 100644 src/test/java/com/zipcodewilmington/scientificcalculator/PromptTest.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java index f5382422..316d3634 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operation.java @@ -15,7 +15,10 @@ public static Boolean isUnary(String op) if ("inv".equals(op) || "bin".equals(op) || "oct".equals(op) || "dec".equals(op) || "hex".equals(op) || "mode".equals(op) || "sq".equals(op) || "sqrt".equals(op) || "sin".equals(op) || "cos".equals(op) || "tan".equals(op) || "invsin".equals(op) || "invcos".equals(op) || "invtan".equals(op) || "log".equals(op) || - "nlog".equals(op) || "invlog".equals(op) || "invnlog".equals(op) || "!".equals(op) || "fib".equals(op)) { + "nlog".equals(op) || "invlog".equals(op) || "invnlog".equals(op) || "!".equals(op) || "fib".equals(op) || + "ftm".equalsIgnoreCase(op) || "mtf".equalsIgnoreCase(op) || "ptk".equalsIgnoreCase(op) || + "ktp".equalsIgnoreCase(op) || "ftc".equalsIgnoreCase(op) || "ctf".equalsIgnoreCase(op)) + { return true; } else { return false; @@ -24,8 +27,8 @@ public static Boolean isUnary(String op) public static Boolean isBinary(String op) { - if("+".equalsIgnoreCase(op) || "-".equalsIgnoreCase(op) || "*".equalsIgnoreCase(op) || - "/".equalsIgnoreCase(op) || "exp".equalsIgnoreCase(op)) { + if("+".equals(op) || "-".equals(op) || "*".equals(op) || + "/".equals(op) || "exp".equals(op)) { return true; } else { diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java index df667790..7b158a4d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Prompt.java @@ -108,9 +108,8 @@ public void parseInput(String s) { { display.setDisplay(BasicMath.multiplication(display.getDisplay(), secondValue)); } else if(s.equalsIgnoreCase("/")) - { display.setDisplay(BasicMath.division(display.getDisplay(), secondValue)); - } else if(s.equalsIgnoreCase("exp")) + else if(s.equalsIgnoreCase("exp")) { display.setDisplay(BasicMath.exponent(display.getDisplay(), secondValue)); } diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/MenuTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/MenuTest.java new file mode 100644 index 00000000..4e471893 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/MenuTest.java @@ -0,0 +1,9 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class MenuTest { + +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/OperationTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/OperationTest.java new file mode 100644 index 00000000..94fb6536 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/OperationTest.java @@ -0,0 +1,68 @@ +package com.zipcodewilmington.scientificcalculator; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class OperationTest { + + @Test + public void TestisSetting() + { + Boolean expected = true; + Operation TestOperation = new Operation(); + Boolean actual = TestOperation.isSetting("c"); + + assertEquals(expected, actual); + } + + @Test + public void TestisSettingAdd() + { + Boolean expected = false; + Operation TestOperation = new Operation(); + Boolean actual = TestOperation.isSetting("+"); + + assertEquals(expected, actual); + } + + @Test + public void TestisSettingBar() + { + Boolean expected = false; + Operation TestOperation = new Operation(); + Boolean actual = TestOperation.isSetting("bar"); + + assertEquals(expected, actual); + } + + @Test + public void TestisSettingMPlus() + { + Boolean expected = true; + Operation TestOperation = new Operation(); + Boolean actual = TestOperation.isSetting("m+"); + + assertEquals(expected, actual); + } + + @Test + public void TestisisUnary() + { + Boolean expected = true; + Operation TestOperation = new Operation(); + Boolean actual = TestOperation.isUnary("nlog"); + + assertEquals(expected, actual); + } + + @Test + public void TestisBinary() + { + Boolean expected = true; + Operation TestOperation = new Operation(); + Boolean actual = TestOperation.isUnary("*"); + + assertEquals(expected, actual); + } +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientificcalculator/PromptTest.java b/src/test/java/com/zipcodewilmington/scientificcalculator/PromptTest.java new file mode 100644 index 00000000..5bd59755 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientificcalculator/PromptTest.java @@ -0,0 +1,7 @@ +package com.zipcodewilmington.scientificcalculator; + +import static org.junit.Assert.*; + +public class PromptTest { + +} \ No newline at end of file From f7b525da0e24c911764d552948169f19d3cd9e5e Mon Sep 17 00:00:00 2001 From: James Wilkinson Date: Sun, 9 Feb 2020 21:09:52 -0500 Subject: [PATCH 53/53] Final submission for demo --- .../com/zipcodewilmington/scientificcalculator/Menu.java | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java index 1b1ca54d..05af54f7 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Menu.java @@ -39,7 +39,12 @@ public static String callMenu() String.format("%-100s", "nlog | N-log of display value"), String.format("%-100s", "invnlog | Inverse N-log of display value"), String.format("%-100s", "! | Factorial of display value"), - String.format("%-100s", "fib | Fibonacci of display value")); - + String.format("%-100s", "fib | Fibonacci of display value"), + String.format("%-100s", "mtf | Meters to feet"), + String.format("%-100s", "ftm | Feet to meters"), + String.format("%-100s", "ktp | Kilograms to pounds"), + String.format("%-100s", "ptk | Pounds to kilograms"), + String.format("%-100s", "ctf | Celsius to Farenheit"), + String.format("%-100s", "ftc | Farenheit to Celsius")); } }