From 9321da63222b73ac939f068ea9e6ac6b3842279e Mon Sep 17 00:00:00 2001 From: vle Date: Fri, 7 Feb 2020 18:30:54 -0500 Subject: [PATCH 01/37] first codes test --- pom.xml | 8 ++++++++ .../scientificcalculator/Operations.java | 8 ++++++++ .../scientific_calculator/OperationsTest.java | 13 +++++++++++++ 3 files changed, 29 insertions(+) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java diff --git a/pom.xml b/pom.xml index e7cb4f6b..3b3b9db4 100644 --- a/pom.xml +++ b/pom.xml @@ -8,5 +8,13 @@ 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/Operations.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java new file mode 100644 index 00000000..f99a1268 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java @@ -0,0 +1,8 @@ +package com.zipcodewilmington.scientificcalculator; + +public class Operations { + + public static long add(long a, long b){ + return a + b; + } +} diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java new file mode 100644 index 00000000..4b5f8aa1 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java @@ -0,0 +1,13 @@ +package com.zipcodewilmington.scientific_calculator; + +import org.junit.Test; + +public class OperationsTest { + + @Test + public void addTest(){ + + long expected = 1000000000; + long actual = add(50000, 50000); + } +} From 3b1fa098fc248d82c7e1b60aa8d91cb0b879c66e Mon Sep 17 00:00:00 2001 From: vle Date: Fri, 7 Feb 2020 19:05:30 -0500 Subject: [PATCH 02/37] next code --- pom.xml | 2 ++ .../scientific_calculator/OperationsTest.java | 9 +++++++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 3b3b9db4..9c1a483f 100644 --- a/pom.xml +++ b/pom.xml @@ -8,6 +8,8 @@ scientific_calculator 1.0-SNAPSHOT + + junit diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java index 4b5f8aa1..f8c2fbae 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java @@ -1,13 +1,18 @@ package com.zipcodewilmington.scientific_calculator; +import com.zipcodewilmington.scientificcalculator.Operations; import org.junit.Test; +import static org.junit.Assert.assertEquals; + public class OperationsTest { @Test public void addTest(){ - + Operations a = new Operations(); long expected = 1000000000; - long actual = add(50000, 50000); + long actual = Operations.add(500000000, 500000000); + assertEquals(expected, actual); + } } From c7a00a8780dabecadd12f1bb5817ea7b16761bd6 Mon Sep 17 00:00:00 2001 From: vle Date: Fri, 7 Feb 2020 19:27:23 -0500 Subject: [PATCH 03/37] add neg test --- .../scientificcalculator/Operations.java | 1 + .../scientific_calculator/OperationsTest.java | 11 +++++++++-- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java index f99a1268..66912656 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java @@ -5,4 +5,5 @@ public class Operations { public static long add(long a, long b){ return a + b; } + } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java index f8c2fbae..6cda7fd8 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java @@ -8,11 +8,18 @@ public class OperationsTest { @Test - public void addTest(){ + public void addTestLarge() { + //add big numbers Operations a = new Operations(); long expected = 1000000000; long actual = Operations.add(500000000, 500000000); assertEquals(expected, actual); - + } + @Test + public void addTestNeg(){ + //add negative numbers + long expected = -1000000000; + long actual = Operations.add(-500000000, -500000000); + assertEquals(expected, actual); } } From 1bd9cde67a1e48726ccefae74d82639b8c4f8ffd Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Fri, 7 Feb 2020 19:32:24 -0500 Subject: [PATCH 04/37] Console changes --- .../scientificcalculator/MainApplication.java | 7 ++++--- .../scientific_calculator/TestMainApplication.java | 6 +++++- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f421325..b4cec816 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -5,13 +5,14 @@ */ public class MainApplication { public static void main(String[] args) { - Console.println("Welcome to my calculator!"); - String s = Console.getStringInput("Enter a string"); + Console.println("Welcome to my calculator! We're here to solve your problems."); + //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 string", s); Console.println("The user input %s as a integer", i); Console.println("The user input %s as a d", d); } } + diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 94e8d987..8422ab42 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -3,5 +3,9 @@ /** * Created by leon on 2/9/18. */ -public class TestMainApplication { +/* public class Calculator { + } + +*/ + From b5bb7bc618e2c38068f1880e36dcee24da5cff8d Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Fri, 7 Feb 2020 21:41:17 -0500 Subject: [PATCH 05/37] added all core features --- .../scientificcalculator/Operations.java | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java index 66912656..5dedaca5 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java @@ -2,8 +2,56 @@ public class Operations { + // CORE FEATURES + //==================================================== + + // Addition public static long add(long a, long b){ return a + b; } + //Subtraction + public double subtract(double num1, double num2) { + return num1 - num2; + } + + // Multiplication + public double multiply (double num1, double num2) { + return num1 * num2; + } + + // Division + public double divide (double num1, double num2) { + return num1 / num2; + } + + // Number Squared + public double square (double num1) { + return num1 * num1; + } + + // Square Root of Number + public double squareRoot (double num1) { + return Math.sqrt(num1); + } + + // Exponent + public double exponent (double num1, double num2) { + return Math.pow (num1, num2); + } + + // Inverse + public double inverse (double num1) { + return (1 / num1); + } + + // Switch from Positive to Negative + public double switchSign (double num1) { + return (-1 * num1); + } + + // Display Error if Divide by 0 + + // Clear Error Before New Operation + } From c5c5e8f3f9c0ea0a21fbda98b6e0fde38725e2f9 Mon Sep 17 00:00:00 2001 From: vle Date: Fri, 7 Feb 2020 23:15:23 -0500 Subject: [PATCH 06/37] console get first number --- .../scientificcalculator/Console.java | 26 +++++++++++++++---- .../scientificcalculator/MainApplication.java | 19 +++++++++----- .../TestMainApplication.java | 20 ++++++++++++++ 3 files changed, 54 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 83f0e97f..2e24976b 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -1,5 +1,7 @@ package com.zipcodewilmington.scientificcalculator; +import javax.swing.plaf.synth.SynthTextAreaUI; +import java.math.BigInteger; import java.util.Scanner; /** @@ -15,18 +17,32 @@ public static void println(String output, Object... args) { print(output + "\n", args); } + public static Scanner scanner; + public static String getStringInput(String prompt) { - Scanner scanner = new Scanner(System.in); + scanner = new Scanner(System.in); println(prompt); String userInput = scanner.nextLine(); - return userInput; + return "Hello there " + userInput + "!"; } - public static Integer getIntegerInput(String prompt) { - return null; + public static Integer getIntegerInput() { + scanner = new Scanner(System.in); + Integer userInput = scanner.nextInt(); + return userInput; } public static Double getDoubleInput(String prompt) { - return null; + scanner = new Scanner(System.in); + println(prompt); + String nextNum = scanner.nextLine(); + double userInput; + try{ + userInput = Double.parseDouble(nextNum); + return userInput; + }catch (Exception e) { + return Console.getDoubleInput("Please enter a number:"); + } } + } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f421325..e4106fa2 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -4,14 +4,21 @@ * Created by leon on 2/9/18. */ public class MainApplication { + public static void main(String[] args) { + int firstInt; + int secondInt; + double firstDouble; + double secondDouble; + String answer = ""; + 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."); + String name = Console.getStringInput("Please enter your name!"); + Console.println(name); + firstDouble = Console.getDoubleInput("Please enter a number:"); + //Console.println(""+firstDouble); + + - Console.println("The user input %s as a string", s); - Console.println("The user input %s as a integer", i); - Console.println("The user input %s as a d", d); } } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 94e8d987..01c65a42 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,7 +1,27 @@ package com.zipcodewilmington.scientific_calculator; +import com.zipcodewilmington.scientificcalculator.Console; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; + /** * Created by leon on 2/9/18. */ public class TestMainApplication { + + /*@Test + public void nameTest(){ + String expected = "Hello there Von!"; + int notExpected = 1; + String actual = Console.getStringInput("Plea"); + assertEquals(expected, actual); + assertNotEquals(notExpected, actual); + }*/ + + @Test + public void numTest(){ + + } } From e83c037e6b84401b782f08dd4c68645b3abb9360 Mon Sep 17 00:00:00 2001 From: vle Date: Sat, 8 Feb 2020 10:44:40 -0500 Subject: [PATCH 07/37] main. working name,firstDouble,operator input --- .../scientificcalculator/Console.java | 49 ++++++++++++++++++- .../scientificcalculator/MainApplication.java | 19 ++++--- 2 files changed, 59 insertions(+), 9 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 2e24976b..5ad640ac 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -20,23 +20,30 @@ public static void println(String output, Object... args) { public static Scanner scanner; public static String getStringInput(String prompt) { + scanner = new Scanner(System.in); println(prompt); String userInput = scanner.nextLine(); + return "Hello there " + userInput + "!"; } public static Integer getIntegerInput() { + scanner = new Scanner(System.in); Integer userInput = scanner.nextInt(); + return userInput; } public static Double getDoubleInput(String prompt) { + + double userInput; + scanner = new Scanner(System.in); println(prompt); String nextNum = scanner.nextLine(); - double userInput; + try{ userInput = Double.parseDouble(nextNum); return userInput; @@ -45,4 +52,44 @@ public static Double getDoubleInput(String prompt) { } } + public static int getOperand(String prompt){ + + scanner = new Scanner(System.in); + println(prompt); + String nextOperand = scanner.nextLine(); + + if(nextOperand.equals("+")){ + // call add method + return 0; + }else if(nextOperand.equals("-")){ + //call subtraction method + return 1; + }else if(nextOperand.equals("*")){ + //call multiply method + return 2; + }else if(nextOperand.equals("/")){ + //call division method + return 3; + }else if(nextOperand.equals("x^2")){ + //call square method + return 4; + }else if(nextOperand.equals("sqrt")){ + //call square root method + return 5; + }else if(nextOperand.equals("x^x")){ + //call power method + return 6; + }else if(nextOperand.equals("1/x")){ + //call inverse method + return 7; + }else if(nextOperand.equals("=")){ + //call equal method + return 8; + }else if(nextOperand.equals("off")){ + //call close method + return 7; + }else{ + return getOperand(prompt); + } + } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index e4106fa2..52bd1078 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -5,20 +5,23 @@ */ public class MainApplication { + public static int firstInt; + public static int secondInt; + public static double firstDouble; + public static double secondDouble; + public static boolean on = true; + public static void main(String[] args) { - int firstInt; - int secondInt; - double firstDouble; - double secondDouble; - String answer = ""; Console.println("Welcome to my calculator!"); String name = Console.getStringInput("Please enter your name!"); Console.println(name); firstDouble = Console.getDoubleInput("Please enter a number:"); //Console.println(""+firstDouble); - - - + String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^x , 1/x, =, off"; + while(on) { + Console.getOperand(operandPrompt); + } } } + From 3da334e9ee45cb0c75176f6c8dfb9c9a79896328 Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sat, 8 Feb 2020 11:16:03 -0500 Subject: [PATCH 08/37] one comment --- .../com/zipcodewilmington/scientificcalculator/Operations.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java index 5dedaca5..1b5d5587 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java @@ -2,6 +2,8 @@ public class Operations { + // For Merging Purposes + // CORE FEATURES //==================================================== From e3361ec68fa92da7733a644c6d8c5172d140620f Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sat, 8 Feb 2020 13:05:38 -0500 Subject: [PATCH 09/37] wrote test cases for Operations.java --- .../scientificcalculator/Operations.java | 6 +-- .../scientificcalculator/ScientificCalc.java | 45 +++++++++++++++++++ 2 files changed, 47 insertions(+), 4 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java index 1b5d5587..3e7242a6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java @@ -2,14 +2,12 @@ public class Operations { - // For Merging Purposes - // CORE FEATURES //==================================================== // Addition - public static long add(long a, long b){ - return a + b; + public double add (double num1, double num2){ + return num1 + num2; } //Subtraction diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java new file mode 100644 index 00000000..1e9b7218 --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -0,0 +1,45 @@ +package com.zipcodewilmington.scientificcalculator; + +public class ScientificCalc { + + // Trig Functions + + // Sine + public double sin (double num1) { + return Math.sin( num1 ); + } + + // Cosine + public double cos (double num1) { + return Math.cos( num1 ); + } + + // Tangent + public double tan (double num1) { + return Math.tan( num1 ); + } + + // Inverse Sine + public double inverseSin (double num1) { + return Math.asin( num1 ); + } + + // Inverse Cosine + public double inverseCos(double num1) { + return Math.acos( num1 ); + } + + // Inverse Tangent + public double inverseTan (double num1) { + return Math.atan( num1 ); + } + + // Logarithmic Functions + + // Log + public double log (double num1) { + return Math.log(num1); + } + + // Inverse Logarithm +} From cedd8e8944ac7281153c98275f0415f37a2c72f0 Mon Sep 17 00:00:00 2001 From: vle Date: Sat, 8 Feb 2020 13:07:37 -0500 Subject: [PATCH 10/37] update console --- .../scientificcalculator/Console.java | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 5ad640ac..e98e4dc6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -52,24 +52,30 @@ public static Double getDoubleInput(String prompt) { } } - public static int getOperand(String prompt){ + public static double getOperand(String prompt){ scanner = new Scanner(System.in); println(prompt); String nextOperand = scanner.nextLine(); + Operations opp = new Operations(); if(nextOperand.equals("+")){ // call add method + MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); + //return Operations.add(MainApplication.firstDouble, MainApplication.secondDouble); return 0; }else if(nextOperand.equals("-")){ //call subtraction method - return 1; + MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); + return opp.subtract(MainApplication.firstDouble, MainApplication.secondDouble); }else if(nextOperand.equals("*")){ //call multiply method - return 2; + MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); + return opp.multiply(MainApplication.firstDouble, MainApplication.secondDouble); }else if(nextOperand.equals("/")){ //call division method - return 3; + MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); + return opp.divide(MainApplication.firstDouble, MainApplication.secondDouble); }else if(nextOperand.equals("x^2")){ //call square method return 4; From 65f602c40c0da5b8952d6da4e0d18819e63f0d7d Mon Sep 17 00:00:00 2001 From: April Howard Date: Sat, 8 Feb 2020 14:32:43 -0500 Subject: [PATCH 11/37] added display class --- .../scientific_calculator/Display.java | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/Display.java diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/Display.java b/src/test/java/com/zipcodewilmington/scientific_calculator/Display.java new file mode 100644 index 00000000..a42607bd --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/Display.java @@ -0,0 +1,43 @@ +package com.zipcodewilmington.scientific_calculator; + +public class Display { + public boolean checkState = true; + double currentNum; + double nextNum; + boolean error; + + public void displayValue(double input){ + + if (checkState) { + currentNum = 0; + System.out.println(currentNum); + checkState = false; + } else { + System.out.println(input); + } + currentNum = input; + + } + + public void displayCurrentValue() { + System.out.println(currentNum); + + } + + public void clearDisplay() { + checkState = true; + displayValue(0); + error = false; + + } + public void changeNumberDisplay(double nextInput) { + currentNum = nextInput; + System.out.println(currentNum); + } + public void displayErr() { + //if math calculations don't work, display 'Err') + error = true; + System.out.println("Err. Clear screen."); + } + +} From 1bb0adf9bc62b4ab25640cd150d5b0a7dc590036 Mon Sep 17 00:00:00 2001 From: April Howard Date: Sat, 8 Feb 2020 14:36:14 -0500 Subject: [PATCH 12/37] moved to proper file --- .../com/zipcodewilmington/scientificcalculator}/Display.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename src/{test/java/com/zipcodewilmington/scientific_calculator => main/java/com/zipcodewilmington/scientificcalculator}/Display.java (94%) diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java similarity index 94% rename from src/test/java/com/zipcodewilmington/scientific_calculator/Display.java rename to src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index a42607bd..e02d5655 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -1,4 +1,4 @@ -package com.zipcodewilmington.scientific_calculator; +package com.zipcodewilmington.scientificcalculator; public class Display { public boolean checkState = true; From 469e7a7dd9ced95347708861d2c1e628507bad92 Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sat, 8 Feb 2020 14:41:37 -0500 Subject: [PATCH 13/37] wrote some Scientific tests --- .../scientificcalculator/ScientificCalc.java | 6 ++++++ .../scientific_calculator/ScientificTests.java | 4 ++++ 2 files changed, 10 insertions(+) create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index 1e9b7218..573fa920 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -42,4 +42,10 @@ public double log (double num1) { } // Inverse Logarithm + + // Natural Log + + // Inverse Natural Log + + // Factorial } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java new file mode 100644 index 00000000..8e8e2645 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java @@ -0,0 +1,4 @@ +package com.zipcodewilmington.scientific_calculator; + +public class ScientificTests { +} From 8d631fc22af00e908e945649b5ea3634a6513bf7 Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sat, 8 Feb 2020 14:46:07 -0500 Subject: [PATCH 14/37] test --- .../scientific_calculator/OperationsTest.java | 134 ++++++++++++++++-- .../ScientificTests.java | 25 ++++ 2 files changed, 148 insertions(+), 11 deletions(-) diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java index 6cda7fd8..04b496c5 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java @@ -7,19 +7,131 @@ public class OperationsTest { + Operations operations = new Operations(); + + // Addition Tests + @Test + public void addPosNums() { + double expected = 50; + double actual = operations.add(23, 27); + assertEquals(expected, actual, 0.01); + } + + @Test + public void addNegNums(){ + double expected = -70; + double actual = operations.add(-50, -20); + assertEquals(expected, actual, 0.01); + } + + // Subtraction Tests + @Test + public void subtractPosNums() { + double expected = 23; + double actual = operations.subtract(50, 27); + assertEquals(expected, actual, 0.01); + } + + @Test + public void subtractNegNums() { + double expected = -30; + double actual = operations.subtract(-50, -20); + assertEquals(expected, actual, 0.01); + } + + // Multiplication Tests + @Test + public void multiplyPosNums() { + double expected = 27; + double actual = operations.multiply(9, 3); + assertEquals(expected, actual, 0.01); + } + + @Test + public void multiplyNegNums() { + double expected = 27; + double actual = operations.multiply(-9, -3); + assertEquals(expected, actual, 0.01); + } + + // Division Tests + @Test + public void dividePosNums() { + double expected = 3; + double actual = operations.divide(9, 3); + assertEquals(expected, actual, 0.01); + } + @Test - public void addTestLarge() { - //add big numbers - Operations a = new Operations(); - long expected = 1000000000; - long actual = Operations.add(500000000, 500000000); - assertEquals(expected, actual); + public void divideNegNums() { + double expected = -3; + double actual = operations.divide(9, -3); + assertEquals(expected, actual, 0.01); } + + // Number Squared Test @Test - public void addTestNeg(){ - //add negative numbers - long expected = -1000000000; - long actual = Operations.add(-500000000, -500000000); - assertEquals(expected, actual); + public void squarePosNums() { + double expected = 9; + double actual = operations.square(3); + assertEquals(expected, actual, 0.01); } + + @Test + public void squareNegNums() { + double expected = 9; + double actual = operations.square(-3); + assertEquals(expected, actual, 0.01); + } + + // Square Root of Numbers + @Test + public void squareRootPosNums() { + double expected = 9; + double actual = operations.squareRoot(81); + assertEquals(expected, actual, 0.01); + } + + // Square Root Negative Numbers Test Case ??? + + // Exponent Tests + @Test + public void exponentNums() { + double expected = 8; + double actual = operations.exponent(2, 3); + assertEquals(expected, actual, 0.01); + } + + // Need To Parse All User Inputs as Doubles + @Test + public void exponentNegNums() { + double expected = 1/8.0; + double actual = operations.exponent(2, -3); + assertEquals(expected, actual, 0.01); + } + + // Inverse + @Test + public void inverseNums() { + double expected = 1/8.0; + double actual = operations.inverse(8); + assertEquals(expected, actual, 0.01); + } + + // Switch Signs + @Test + public void switchSigns() { + double expected = -8; + double actual = operations.switchSign(8); + assertEquals(expected, actual, 0.01); + } + + @Test + public void switchSignsPosToNeg() { + double expected = -8; + double actual = operations.switchSign(8); + assertEquals(expected, actual, 0.01); + } + + } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java index 8e8e2645..f104666b 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java @@ -1,4 +1,29 @@ package com.zipcodewilmington.scientific_calculator; +import com.zipcodewilmington.scientificcalculator.ScientificCalc; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + public class ScientificTests { + + ScientificCalc scientific = new ScientificCalc(); + + // Sine Tests in Radians and Degrees + @Test + public void sinRadians() { + double expected = 0; + double actual = scientific.sin(0); + assertEquals(expected, actual, 0.01); + } + + /* + @Test + public void sinRadians() { + double expected = 0; + double actual = scientific.sin(0); + assertEquals(expected, actual, 0.01); + } + */ + } From 980a2808c655033abb1a018007464be9be2e24dd Mon Sep 17 00:00:00 2001 From: vle Date: Sat, 8 Feb 2020 14:48:17 -0500 Subject: [PATCH 15/37] test --- .../com/zipcodewilmington/scientificcalculator/Console.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index e98e4dc6..92acb092 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -62,8 +62,7 @@ public static double getOperand(String prompt){ if(nextOperand.equals("+")){ // call add method MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - //return Operations.add(MainApplication.firstDouble, MainApplication.secondDouble); - return 0; + return opp.add(MainApplication.firstDouble, MainApplication.secondDouble); }else if(nextOperand.equals("-")){ //call subtraction method MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); From 3b7d7f744d7d89c744b4faf0240d241b965d6467 Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sat, 8 Feb 2020 16:46:25 -0500 Subject: [PATCH 16/37] wrote most of scientific methods --- .../scientificcalculator/ScientificCalc.java | 20 ++- .../ScientificTests.java | 124 +++++++++++++++++- 2 files changed, 142 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index 573fa920..a2706044 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -38,14 +38,32 @@ public double inverseTan (double num1) { // Log public double log (double num1) { - return Math.log(num1); + return Math.log10(num1); } // Inverse Logarithm + public double inverseLog (double num1) { + return Math.exp(num1); + } // Natural Log + public double naturalLog (double num1) { + return Math.log(num1); + } // Inverse Natural Log + /* public double inverseNaturalLog (double num1) { + return Math.pow(10, num1); + } + */ // Factorial + public int factorial (int num1) { + int sum = 1; + for (int i = 2; i <= num1 ; i++) { + sum *= i; + } + return sum; + } + } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java index f104666b..3123f259 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java @@ -19,11 +19,133 @@ public void sinRadians() { /* @Test - public void sinRadians() { + public void sinDegrees() { double expected = 0; double actual = scientific.sin(0); assertEquals(expected, actual, 0.01); } */ + // Cosine Tests in Radians and Degrees + @Test + public void cosRadians() { + double expected = 1; + double actual = scientific.cos(0); + assertEquals(expected, actual, 0.01); + } + + /* + @Test + public void cosDegrees() { + double expected = 0; + double actual = scientific.cos(0); + assertEquals(expected, actual, 0.01); + } + */ + + // Tangent Tests in Radians and Degrees + @Test + public void tanRadians() { + double expected = 0; + double actual = scientific.tan(0); + assertEquals(expected, actual, 0.01); + } + + /* + @Test + public void tanDegrees() { + double expected = 0; + double actual = scientific.tan(0); + assertEquals(expected, actual, 0.01); + } + */ + + // Inverse Sine Tests in Radians and Degrees + @Test + public void inverseSinRadians() { + double expected = 0; + double actual = scientific.inverseSin(0); + assertEquals(expected, actual, 0.01); + } + + /* + @Test + public void inverseSinDegrees() { + double expected = 0; + double actual = scientific.inverseSin(0); + assertEquals(expected, actual, 0.01); + } + */ + + // Inverse Cosine Tests in Radians and Degrees + @Test + public void inverseCosRadians() { + double expected = 0; + double actual = scientific.inverseCos(1); + assertEquals(expected, actual, 0.01); + } + + /* + @Test + public void inverseCosDegrees() { + double expected = 0; + double actual = scientific.inverseCos(0); + assertEquals(expected, actual, 0.01); + } + */ + + // Inverse Tangent Tests in Radians and Degrees + @Test + public void inverseTanRadians() { + double expected = 0; + double actual = scientific.inverseTan(0); + assertEquals(expected, actual, 0.01); + } + + /* + @Test + public void inverseTanDegrees() { + double expected = 0; + double actual = scientific.inverseTan(0); + assertEquals(expected, actual, 0.01); + } + */ + + // Logarithmic Functions + + // Log + @Test + public void log () { + double expected = 0; + double actual = scientific.log(1); + assertEquals(expected, actual, 0.01); + } + + // Inverse Log + @Test + public void inverseLog () { + double expected = 1; + double actual = scientific.inverseLog(0); + assertEquals(expected, actual, 0.01); + } + + // Natural Log + @Test + public void naturalLog () { + double expected = 0; + double actual = scientific.naturalLog(1); + assertEquals(expected, actual, 0.01); + } + + // Inverse Natural Log + + + // Factorial + @Test + public void factorial () { + double expected = 120; + double actual = scientific.factorial(5); + assertEquals(expected, actual, 0.01); + } + } From 1f62b9fe562747bd10dd284618d211cec4701a2f Mon Sep 17 00:00:00 2001 From: vle Date: Sat, 8 Feb 2020 17:08:13 -0500 Subject: [PATCH 17/37] some logic works --- .../scientificcalculator/Console.java | 151 +++++++++++++++--- .../scientificcalculator/Display.java | 28 ++-- .../scientificcalculator/MainApplication.java | 3 +- 3 files changed, 140 insertions(+), 42 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 92acb092..e59146e9 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -52,8 +52,9 @@ public static Double getDoubleInput(String prompt) { } } - public static double getOperand(String prompt){ + public static void getOperand(String prompt){ + Display display = new Display(); scanner = new Scanner(System.in); println(prompt); String nextOperand = scanner.nextLine(); @@ -61,40 +62,144 @@ public static double getOperand(String prompt){ if(nextOperand.equals("+")){ // call add method - MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - return opp.add(MainApplication.firstDouble, MainApplication.secondDouble); + if(!Display.error) { + MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); + if(Display.checkState){ + Display.currentTotal = (opp.add(MainApplication.firstDouble, MainApplication.secondDouble)); + display.displayCurrentValue(); + Display.total = Display.currentTotal; + Display.checkState = false; + }else { + Display.currentTotal = (opp.add(Display.total, MainApplication.secondDouble)); + display.displayValue(Display.currentTotal); + Display.total = Display.currentTotal; + } + }else { + display.displayErr(); + } }else if(nextOperand.equals("-")){ //call subtraction method - MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - return opp.subtract(MainApplication.firstDouble, MainApplication.secondDouble); + if(!Display.error){ + MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); + if(Display.checkState){ + Display.currentTotal = (opp.subtract(MainApplication.firstDouble, MainApplication.secondDouble)); + display.displayCurrentValue(); + Display.total = Display.currentTotal; + Display.checkState = false; + }else { + Display.currentTotal = (opp.subtract(Display.total, MainApplication.secondDouble)); + display.displayValue(Display.currentTotal); + Display.total = Display.currentTotal; + } + }else { + display.displayErr(); + } }else if(nextOperand.equals("*")){ //call multiply method - MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - return opp.multiply(MainApplication.firstDouble, MainApplication.secondDouble); + if(!Display.error) { + MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); + if(Display.checkState){ + Display.currentTotal = (opp.multiply(MainApplication.firstDouble, MainApplication.secondDouble)); + display.displayCurrentValue(); + Display.total = Display.currentTotal; + Display.checkState = false; + }else { + Display.currentTotal = (opp.multiply(Display.total, MainApplication.secondDouble)); + display.displayValue(Display.currentTotal); + Display.total = Display.currentTotal; + } + }else { + display.displayErr(); + } }else if(nextOperand.equals("/")){ //call division method - MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - return opp.divide(MainApplication.firstDouble, MainApplication.secondDouble); - }else if(nextOperand.equals("x^2")){ + if(!Display.error) { + MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); + if(Display.checkState){ + Display.currentTotal = (opp.divide(MainApplication.firstDouble, MainApplication.secondDouble)); + display.displayCurrentValue(); + Display.total = Display.currentTotal; + Display.checkState = false; + }else { + Display.currentTotal = (opp.divide(Display.total, MainApplication.secondDouble)); + display.displayValue(Display.currentTotal); + Display.total = Display.currentTotal; + } + }else { + display.displayErr(); + } + }else if(nextOperand.equalsIgnoreCase("x^2")){ //call square method - return 4; - }else if(nextOperand.equals("sqrt")){ + if(!Display.error) { + if(Display.checkState){ + Display.currentTotal = (opp.square(MainApplication.firstDouble)); + display.displayCurrentValue(); + Display.total = Display.currentTotal; + Display.checkState = false; + }else { + Display.currentTotal = (opp.square(Display.total)); + display.displayValue(Display.currentTotal); + Display.total = Display.currentTotal; + } + }else { + display.displayErr(); + } + }else if(nextOperand.equalsIgnoreCase("sqrt")){ //call square root method - return 5; - }else if(nextOperand.equals("x^x")){ + if(!Display.error) { + if(Display.checkState){ + Display.currentTotal = (opp.squareRoot(MainApplication.firstDouble)); + display.displayCurrentValue(); + Display.total = Display.currentTotal; + Display.checkState = false; + }else { + Display.currentTotal = (opp.squareRoot(Display.total)); + display.displayValue(Display.currentTotal); + Display.total = Display.currentTotal; + } + }else { + display.displayErr(); + } + }else if(nextOperand.equalsIgnoreCase("x^x")){ //call power method - return 6; - }else if(nextOperand.equals("1/x")){ + if(!Display.error) { + MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); + if(Display.checkState){ + Display.currentTotal = (opp.exponent(MainApplication.firstDouble, MainApplication.secondDouble)); + display.displayCurrentValue(); + Display.total = Display.currentTotal; + Display.checkState = false; + }else { + Display.currentTotal = (opp.exponent(Display.total, MainApplication.secondDouble)); + display.displayValue(Display.currentTotal); + Display.total = Display.currentTotal; + } + }else { + display.displayErr(); + } + }else if(nextOperand.equalsIgnoreCase("1/x")){ //call inverse method - return 7; - }else if(nextOperand.equals("=")){ - //call equal method - return 8; - }else if(nextOperand.equals("off")){ + if(!Display.error) { + if(Display.checkState){ + Display.currentTotal = (opp.inverse(MainApplication.firstDouble)); + display.displayCurrentValue(); + Display.total = Display.currentTotal; + Display.checkState = false; + }else { + Display.currentTotal = (opp.inverse(Display.total)); + display.displayValue(Display.currentTotal); + Display.total = Display.currentTotal; + } + }else { + display.displayErr(); + } + }else if(nextOperand.equalsIgnoreCase("c")){ + display.clearDisplay(); + }else if(nextOperand.equalsIgnoreCase("off")){ //call close method - return 7; + display.clearDisplay(); }else{ - return getOperand(prompt); + getDoubleInput(prompt); } } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index e02d5655..82349024 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -1,38 +1,32 @@ package com.zipcodewilmington.scientificcalculator; public class Display { - public boolean checkState = true; - double currentNum; - double nextNum; - boolean error; + public static boolean checkState = true; + public static double total = 0; + public static double currentTotal = 0; + public static boolean error; public void displayValue(double input){ - if (checkState) { - currentNum = 0; - System.out.println(currentNum); - checkState = false; - } else { - System.out.println(input); - } - currentNum = input; - + System.out.println(input); } public void displayCurrentValue() { - System.out.println(currentNum); + System.out.println(currentTotal); } public void clearDisplay() { checkState = true; - displayValue(0); + total = 0; + currentTotal = 0; + displayValue(total); error = false; } public void changeNumberDisplay(double nextInput) { - currentNum = nextInput; - System.out.println(currentNum); + total = nextInput; + System.out.println(total); } public void displayErr() { //if math calculations don't work, display 'Err') diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 52bd1078..12d3bbc1 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -17,8 +17,7 @@ public static void main(String[] args) { String name = Console.getStringInput("Please enter your name!"); Console.println(name); firstDouble = Console.getDoubleInput("Please enter a number:"); - //Console.println(""+firstDouble); - String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^x , 1/x, =, off"; + String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^x , 1/x, c"; while(on) { Console.getOperand(operandPrompt); } From 3ac440b2f4c311504ffcd02d56df2d68d1ecdb03 Mon Sep 17 00:00:00 2001 From: April Howard Date: Sun, 9 Feb 2020 13:16:31 -0500 Subject: [PATCH 18/37] wrote more tests --- .DS_Store | Bin 0 -> 6148 bytes src/.DS_Store | Bin 0 -> 6148 bytes src/main/.DS_Store | Bin 0 -> 6148 bytes src/main/java/.DS_Store | Bin 0 -> 6148 bytes src/main/java/com/.DS_Store | Bin 0 -> 6148 bytes src/test/.DS_Store | Bin 0 -> 6148 bytes src/test/java/.DS_Store | Bin 0 -> 6148 bytes src/test/java/com/.DS_Store | Bin 0 -> 6148 bytes .../scientific_calculator/OperationsTest.java | 42 ++++++++++++++++++ 9 files changed, 42 insertions(+) create mode 100644 .DS_Store create mode 100644 src/.DS_Store create mode 100644 src/main/.DS_Store create mode 100644 src/main/java/.DS_Store create mode 100644 src/main/java/com/.DS_Store create mode 100644 src/test/.DS_Store create mode 100644 src/test/java/.DS_Store create mode 100644 src/test/java/com/.DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..3833d0c095466354fc23a0733bbda6748c967885 GIT binary patch literal 6148 zcmeHK&2G~`5T0#9vk5}vP^sm%7bFf*m58cUg^)~|9(q7R7{LKhYR93qmAgq7)~^iFqqcD zQ`)CT)T771P2@#p#h+(avD%fLrSRtzJU&?4-F`R9m59bk(8lc{A&-HS7hs# zDppW2qru|1?Bmr@;Upi0iLUi693^pHwA%87? zZcL|JySpvX>1@whV!E@_Zi%h?+p}4nuix!FJUBdg_kMad`|t@3 zJ2JC36sAW}J{9YGRvS;hk x$}LG!4!;2L37oKLNEMlmP$$ literal 0 HcmV?d00001 diff --git a/src/.DS_Store b/src/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..6757a66572f8846ae5843e431cf51dcb00e933d2 GIT binary patch literal 6148 zcmeHK!EVz)5S?vJy9q+%P^mrog2bVRL@o4ykgQM+y;X8m4uBGyMAVY&tzw6Wh9Lh& z`v-gqU(nBiH@icmq;Le0Xh)iTvpX|u@3VH-Lqw`O9(0IWM5LjNK@-hyg#E1dWJ5-_ zfQsih$<2o}H!1o&p%>49XW;*4fcI`dmy}RO#nS$L0pHUfR_r3?ap|PIl70R?y~?w) zYPavy#%AzfYg_B4Za!+hk1xz5u99k8c9YRt?wuypMJo20G5Oq1((`OM>9uxVnW9Rv zVmPwN*@N;IK2>52r^*un!NO&t?t1 z`=s;oq<{JOdirJd^~QY%g@ek0EBEI9g*^kFfxpcFpAR9FF%qmD+M@%FEdhW5hONN1zy83G z2Y``a?GPgn z8Q65)7T^D`v4{Uq|1T!_o@c-_uvQGH;5a_+Vo7qh-dh~swIQ?*W#PEmp-n*}*ReJD eD&B)yfiGkO7zx%6F#_>F0+t5fcn1C{13v-no2du@ literal 0 HcmV?d00001 diff --git a/src/main/.DS_Store b/src/main/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5e7194266fb041a8b4b83cf336ffd2777672a3a7 GIT binary patch literal 6148 zcmeHK%}T>S5Z)2Ini5ke>^VWEWK8=-m9FH&%xF`%S1b`yOb zB|5@0Ey(i!8KAu@iYpO{TM>TRzYWYSz8Nuv4CA71`^N3_OLUXO?W|gTm4&h5_{5}A zWmTRop9Gh>8)RYDY1hNn5k2jN*=6MHeXWzB9YzOnvwK>Z-O_0m#%Z%kstE0rVZ_7U6+Nn+mk4(zO`Ubq>;|W8Qc1xkZ~U zqfOzh^4D|9%=-Bj|`yiFt-Q~gntAK4LmRdf6Bl+y=Ge8 literal 0 HcmV?d00001 diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..7f97956eca48bb63325fcc16870e15484656a92e GIT binary patch literal 6148 zcmeHK%}OId5bjRmZYPVFgRmawB6#qS;NL+OhO8dE2_t$?(HRrgfpJ=r$%Zu>nb*)a z@(Fw#{i?enhcS^o>;5Qw3^T z!(JqrP4Gm^iTn=?(B4(mg|g~uFMG9r+n8B-a^ec%sAM#_=3RbBuCsJdv|5k4QmxH> z`D#qVH0B$p(WMZX3yTpEuz+O5@KZM{8N4aQqru-Df%CzHDQzTEz?cYgKf zX8d<@d*^pT<0Eylz&M3_7+l`(sGnyx{{_!9dKx7t3iz0@IbUr1^QIYEr#aaLHl&fha6ve z^yx~wH)9=sv*r#(bL*i47p`>ZQAS}v7u-@2oFSl1RM=A2m}9=foJ8T BSp5J1 literal 0 HcmV?d00001 diff --git a/src/main/java/com/.DS_Store b/src/main/java/com/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..0c39755fb76e9eaff0703b8924be718622d9ac6d GIT binary patch literal 6148 zcmeHK&1%~~5T13MX6;hqLZCV766hfZoBSP0K)C54w}MJ@NJ}C`CJ`uFW6Ke>>!R0a z->6T}$7#RWU56H@kW&-N49tF`*_m1Pli1Y|k?K#<9#MygG?cN?!f=Q1JnND)yk`Zd zYz;#x4XC1w@}+2TJVpli-94u%-q?^X==b+`4PQZ*RKi;v=jI~GO@e6tR9-<}{|O@+$H6J7e-& zJ5JtbgX*la@!Aw+oE3wSP0rE*LOz^iMQWuk9-m)-n$AAYzkIcuBZZIK%DTq|e1mZh@@}G0k(=TY(Thrp z3WCCbFdz&(2m}5w(oY{`by-vx5C$GI1AIONP{z<>?a&?_7;FmwY{G2?Hvb@UPT(>0 zSUbcFM7dO;OI5zbP%a(*z{iCiYlkkKly5$iUs?GMMcLI+Kd|AXLWeR61H!G1vk=I{N#4U$0^5C;BF22}GXI_hI@{%&2`CEv9H^c>2S5Z)2Ini5ke>^VWEWK8=-m9FH&%xF`%S1b`yOb zB|5@0Ey(i!8KAu@iYpO{TM>TRzYWYSz8Nuv4CA71`^N3_OLUXO?W|gTm4&h5_{5}A zWmTRop9Gh>8)RYDY1hNn5k2jN*=6MHeXWzB9YzOnvwK>Z-O_0m#%Z%kstE0rVZ_7U6+Nn+mk4(zO`Ubq>;|W8Qc1xkZ~U zqfOzh^4D|9%=-Bj|`yiFt-Q~gntAK4LmRdf6Bl+y=Ge8 literal 0 HcmV?d00001 diff --git a/src/test/java/.DS_Store b/src/test/java/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..7f97956eca48bb63325fcc16870e15484656a92e GIT binary patch literal 6148 zcmeHK%}OId5bjRmZYPVFgRmawB6#qS;NL+OhO8dE2_t$?(HRrgfpJ=r$%Zu>nb*)a z@(Fw#{i?enhcS^o>;5Qw3^T z!(JqrP4Gm^iTn=?(B4(mg|g~uFMG9r+n8B-a^ec%sAM#_=3RbBuCsJdv|5k4QmxH> z`D#qVH0B$p(WMZX3yTpEuz+O5@KZM{8N4aQqru-Df%CzHDQzTEz?cYgKf zX8d<@d*^pT<0Eylz&M3_7+l`(sGnyx{{_!9dKx7t3iz0@IbUr1^QIYEr#aaLHl&fha6ve z^yx~wH)9=sv*r#(bL*i47p`>ZQAS}v7u-@2oFSl1RM=A2m}9=foJ8T BSp5J1 literal 0 HcmV?d00001 diff --git a/src/test/java/com/.DS_Store b/src/test/java/com/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..0c39755fb76e9eaff0703b8924be718622d9ac6d GIT binary patch literal 6148 zcmeHK&1%~~5T13MX6;hqLZCV766hfZoBSP0K)C54w}MJ@NJ}C`CJ`uFW6Ke>>!R0a z->6T}$7#RWU56H@kW&-N49tF`*_m1Pli1Y|k?K#<9#MygG?cN?!f=Q1JnND)yk`Zd zYz;#x4XC1w@}+2TJVpli-94u%-q?^X==b+`4PQZ*RKi;v=jI~GO@e6tR9-<}{|O@+$H6J7e-& zJ5JtbgX*la@!Aw+oE3wSP0rE*LOz^iMQWuk9-m)-n$AAYzkIcuBZZIK%DTq|e1mZh@@}G0k(=TY(Thrp z3WCCbFdz&(2m}5w(oY{`by-vx5C$GI1AIONP{z<>?a&?_7;FmwY{G2?Hvb@UPT(>0 zSUbcFM7dO;OI5zbP%a(*z{iCiYlkkKly5$iUs?GMMcLI+Kd|AXLWeR61H!G1vk=I{N#4U$0^5C;BF22}GXI_hI@{%&2`CEv9H^c>2 Date: Sun, 9 Feb 2020 13:47:16 -0500 Subject: [PATCH 19/37] added display mode logic --- .../scientificcalculator/Console.java | 5 +- .../scientificcalculator/MainApplication.java | 10 +- .../scientificcalculator/Operations.java | 6 +- .../scientificcalculator/ScientificCalc.java | 94 ++++++++++++++++--- .../ScientificTests.java | 2 +- 5 files changed, 98 insertions(+), 19 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index e59146e9..99671da6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -24,7 +24,6 @@ public static String getStringInput(String prompt) { scanner = new Scanner(System.in); println(prompt); String userInput = scanner.nextLine(); - return "Hello there " + userInput + "!"; } @@ -32,7 +31,6 @@ public static Integer getIntegerInput() { scanner = new Scanner(System.in); Integer userInput = scanner.nextInt(); - return userInput; } @@ -203,3 +201,6 @@ public static void getOperand(String prompt){ } } } + + + diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 12d3bbc1..9e23b44f 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,5 +1,6 @@ package com.zipcodewilmington.scientificcalculator; +import static java.lang.Integer.*; /** * Created by leon on 2/9/18. */ @@ -13,13 +14,18 @@ public class MainApplication { public static void main(String[] args) { - Console.println("Welcome to my calculator!"); + Operations op = new Operations(); + ScientificCalc sciCalc = new ScientificCalc(); + //sciCalc.displayMode = "decimal"; + //sciCalc.unitsMode = "Degrees"; + + Console.println("Welcome to my calculator!" + "\n" + "Let's do some stuff!"); String name = Console.getStringInput("Please enter your name!"); Console.println(name); firstDouble = Console.getDoubleInput("Please enter a number:"); String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^x , 1/x, c"; while(on) { - Console.getOperand(operandPrompt); + Console.getOperand(operandPrompt); } } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java index 3e7242a6..87328ef8 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java @@ -1,5 +1,7 @@ package com.zipcodewilmington.scientificcalculator; +import static java.lang.Math.*; + public class Operations { // CORE FEATURES @@ -32,12 +34,12 @@ public double square (double num1) { // Square Root of Number public double squareRoot (double num1) { - return Math.sqrt(num1); + return sqrt(num1); } // Exponent public double exponent (double num1, double num2) { - return Math.pow (num1, num2); + return pow (num1, num2); } // Inverse diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index a2706044..655129fb 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -1,61 +1,62 @@ package com.zipcodewilmington.scientificcalculator; +import static java.lang.Math.*; + public class ScientificCalc { // Trig Functions // Sine public double sin (double num1) { - return Math.sin( num1 ); + return sin( num1 ); } // Cosine public double cos (double num1) { - return Math.cos( num1 ); + return cos( num1 ); } // Tangent public double tan (double num1) { - return Math.tan( num1 ); + return tan( num1 ); } // Inverse Sine public double inverseSin (double num1) { - return Math.asin( num1 ); + return asin( num1 ); } // Inverse Cosine public double inverseCos(double num1) { - return Math.acos( num1 ); + return acos( num1 ); } // Inverse Tangent public double inverseTan (double num1) { - return Math.atan( num1 ); + return atan( num1 ); } // Logarithmic Functions // Log - public double log (double num1) { - return Math.log10(num1); + public double logarithm (double num1) { + return log10(num1); } // Inverse Logarithm public double inverseLog (double num1) { - return Math.exp(num1); + return exp(num1); } // Natural Log public double naturalLog (double num1) { - return Math.log(num1); + return log(num1); } // Inverse Natural Log - /* public double inverseNaturalLog (double num1) { + public double inverseNaturalLog (double num1) { return Math.pow(10, num1); } - */ // Factorial public int factorial (int num1) { @@ -66,4 +67,73 @@ public int factorial (int num1) { return sum; } + // Switch Between Radians and Degrees + public double toRadians (double num1) { + return toRadians (num1); + } + + // Switch Between Radians and Degrees + public double toDegrees (double num1) { + return toDegrees (num1); + } + + // Units Mode + public String unitsMode; + + public void switchUnitsMode(){ + if (unitsMode.equals("Degrees")) { + unitsMode = "Radians"; + } + else { + unitsMode = "Degrees"; + } + } + + public void switchUnitsMode (String mode) { + unitsMode = mode; + } + + // Display Mode + public String displayMode; + + public void setDisplayMode(String disp) { + this.displayMode = disp; + } + public String getDisplayMode(){ + return this.displayMode; + } + + public void switchDisplayMode() { + if (displayMode.equals("binary")) { + displayMode = "octal"; + } else if (displayMode.equals("octal")) { + displayMode = "decimal"; + } else if (displayMode.equals("decimal")) { + displayMode = "hexadecimal"; + } else { + displayMode = "binary"; + } + } + + public void switchDisplayMode(String mode) { + displayMode = mode; + } + + public double a; + + // Store Memory + public void storeMemory(double mem) { + this.a = mem; + } + + // Clear Memory + public void clearMemory() { + this.a = Double.NaN; + } + + // Recall Memory + public double memoryRecall(){ + return this.a; + } + } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java index 3123f259..d3d20abd 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java @@ -117,7 +117,7 @@ public void inverseTanDegrees() { @Test public void log () { double expected = 0; - double actual = scientific.log(1); + double actual = scientific.logarithm(1); assertEquals(expected, actual, 0.01); } From eaf81586129ec7a2e90ae538e982a2cd592f4ea3 Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 14:48:20 -0500 Subject: [PATCH 20/37] moved logic to main app --- .../scientificcalculator/Console.java | 146 ++---------------- .../scientificcalculator/Display.java | 6 +- .../scientificcalculator/MainApplication.java | 78 ++++++++-- 3 files changed, 85 insertions(+), 145 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index e59146e9..e5484350 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -1,5 +1,7 @@ package com.zipcodewilmington.scientificcalculator; +import sun.applet.Main; + import javax.swing.plaf.synth.SynthTextAreaUI; import java.math.BigInteger; import java.util.Scanner; @@ -52,154 +54,34 @@ public static Double getDoubleInput(String prompt) { } } - public static void getOperand(String prompt){ + public static int getOperand(String prompt){ - Display display = new Display(); scanner = new Scanner(System.in); println(prompt); String nextOperand = scanner.nextLine(); - Operations opp = new Operations(); if(nextOperand.equals("+")){ - // call add method - if(!Display.error) { - MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - if(Display.checkState){ - Display.currentTotal = (opp.add(MainApplication.firstDouble, MainApplication.secondDouble)); - display.displayCurrentValue(); - Display.total = Display.currentTotal; - Display.checkState = false; - }else { - Display.currentTotal = (opp.add(Display.total, MainApplication.secondDouble)); - display.displayValue(Display.currentTotal); - Display.total = Display.currentTotal; - } - }else { - display.displayErr(); - } + return 1; }else if(nextOperand.equals("-")){ - //call subtraction method - if(!Display.error){ - MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - if(Display.checkState){ - Display.currentTotal = (opp.subtract(MainApplication.firstDouble, MainApplication.secondDouble)); - display.displayCurrentValue(); - Display.total = Display.currentTotal; - Display.checkState = false; - }else { - Display.currentTotal = (opp.subtract(Display.total, MainApplication.secondDouble)); - display.displayValue(Display.currentTotal); - Display.total = Display.currentTotal; - } - }else { - display.displayErr(); - } + return 2; }else if(nextOperand.equals("*")){ - //call multiply method - if(!Display.error) { - MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - if(Display.checkState){ - Display.currentTotal = (opp.multiply(MainApplication.firstDouble, MainApplication.secondDouble)); - display.displayCurrentValue(); - Display.total = Display.currentTotal; - Display.checkState = false; - }else { - Display.currentTotal = (opp.multiply(Display.total, MainApplication.secondDouble)); - display.displayValue(Display.currentTotal); - Display.total = Display.currentTotal; - } - }else { - display.displayErr(); - } + return 3; }else if(nextOperand.equals("/")){ - //call division method - if(!Display.error) { - MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - if(Display.checkState){ - Display.currentTotal = (opp.divide(MainApplication.firstDouble, MainApplication.secondDouble)); - display.displayCurrentValue(); - Display.total = Display.currentTotal; - Display.checkState = false; - }else { - Display.currentTotal = (opp.divide(Display.total, MainApplication.secondDouble)); - display.displayValue(Display.currentTotal); - Display.total = Display.currentTotal; - } - }else { - display.displayErr(); - } + return 4; }else if(nextOperand.equalsIgnoreCase("x^2")){ - //call square method - if(!Display.error) { - if(Display.checkState){ - Display.currentTotal = (opp.square(MainApplication.firstDouble)); - display.displayCurrentValue(); - Display.total = Display.currentTotal; - Display.checkState = false; - }else { - Display.currentTotal = (opp.square(Display.total)); - display.displayValue(Display.currentTotal); - Display.total = Display.currentTotal; - } - }else { - display.displayErr(); - } + return 5; }else if(nextOperand.equalsIgnoreCase("sqrt")){ - //call square root method - if(!Display.error) { - if(Display.checkState){ - Display.currentTotal = (opp.squareRoot(MainApplication.firstDouble)); - display.displayCurrentValue(); - Display.total = Display.currentTotal; - Display.checkState = false; - }else { - Display.currentTotal = (opp.squareRoot(Display.total)); - display.displayValue(Display.currentTotal); - Display.total = Display.currentTotal; - } - }else { - display.displayErr(); - } + return 6; }else if(nextOperand.equalsIgnoreCase("x^x")){ - //call power method - if(!Display.error) { - MainApplication.secondDouble = Console.getDoubleInput("Please enter a number:"); - if(Display.checkState){ - Display.currentTotal = (opp.exponent(MainApplication.firstDouble, MainApplication.secondDouble)); - display.displayCurrentValue(); - Display.total = Display.currentTotal; - Display.checkState = false; - }else { - Display.currentTotal = (opp.exponent(Display.total, MainApplication.secondDouble)); - display.displayValue(Display.currentTotal); - Display.total = Display.currentTotal; - } - }else { - display.displayErr(); - } + return 7; }else if(nextOperand.equalsIgnoreCase("1/x")){ - //call inverse method - if(!Display.error) { - if(Display.checkState){ - Display.currentTotal = (opp.inverse(MainApplication.firstDouble)); - display.displayCurrentValue(); - Display.total = Display.currentTotal; - Display.checkState = false; - }else { - Display.currentTotal = (opp.inverse(Display.total)); - display.displayValue(Display.currentTotal); - Display.total = Display.currentTotal; - } - }else { - display.displayErr(); - } + return 8; }else if(nextOperand.equalsIgnoreCase("c")){ - display.clearDisplay(); + return 0; }else if(nextOperand.equalsIgnoreCase("off")){ - //call close method - display.clearDisplay(); + return 100; }else{ - getDoubleInput(prompt); + return getOperand(prompt); } } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 82349024..2a3f07f0 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -1,7 +1,7 @@ package com.zipcodewilmington.scientificcalculator; public class Display { - public static boolean checkState = true; + public boolean checkState = true; public static double total = 0; public static double currentTotal = 0; public static boolean error; @@ -11,8 +11,8 @@ public void displayValue(double input){ System.out.println(input); } - public void displayCurrentValue() { - System.out.println(currentTotal); + public void displayCurrentValue(double input) { + System.out.println(input); } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 12d3bbc1..6d8c0ea4 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -5,21 +5,79 @@ */ public class MainApplication { - public static int firstInt; - public static int secondInt; - public static double firstDouble; - public static double secondDouble; - public static boolean on = true; - public static void main(String[] args) { + double input; + double total = 0; + double currentTotal = 0; + int operand; + Display display = new Display(); + Operations opp = new Operations(); + double firstDouble; + boolean on = true; + Console.println("Welcome to my calculator!"); String name = Console.getStringInput("Please enter your name!"); Console.println(name); - firstDouble = Console.getDoubleInput("Please enter a number:"); - String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^x , 1/x, c"; - while(on) { - Console.getOperand(operandPrompt); + String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^x , 1/x, c, off"; + while (on){ + if(display.checkState){ + input = Console.getDoubleInput("Please enter a number:"); + total = input; + display.checkState = false; + }else { + operand = Console.getOperand(operandPrompt); + switch (operand){ + case 100: + on = false; + break; + case 0: + display.clearDisplay(); + break; + case 1: + currentTotal = opp.add(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + break; + case 2: + currentTotal = opp.subtract(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + break; + case 3: + currentTotal = opp.multiply(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + break; + case 4: + currentTotal = opp.divide(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + break; + case 5: + currentTotal = opp.square(total); + display.displayValue(currentTotal); + total = currentTotal; + break; + case 6: + currentTotal = opp.squareRoot(total); + display.displayValue(currentTotal); + total = currentTotal; + break; + case 7: + currentTotal = opp.exponent(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + break; + case 8: + currentTotal = opp.inverse(total); + display.displayValue(currentTotal); + total = currentTotal; + break; + + } + + } } } } From b8dfee79f11ade451b315ac5a82af01672865eab Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sun, 9 Feb 2020 14:55:59 -0500 Subject: [PATCH 21/37] fixed sign test for other case --- .../scientificcalculator/ScientificCalc.java | 58 +------------------ .../scientific_calculator/OperationsTest.java | 4 +- 2 files changed, 3 insertions(+), 59 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index 655129fb..bb485730 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -67,6 +67,7 @@ public int factorial (int num1) { return sum; } + /* // Switch Between Radians and Degrees public double toRadians (double num1) { return toRadians (num1); @@ -77,63 +78,6 @@ public double toDegrees (double num1) { return toDegrees (num1); } - // Units Mode - public String unitsMode; - public void switchUnitsMode(){ - if (unitsMode.equals("Degrees")) { - unitsMode = "Radians"; - } - else { - unitsMode = "Degrees"; - } - } - - public void switchUnitsMode (String mode) { - unitsMode = mode; - } - - // Display Mode - public String displayMode; - - public void setDisplayMode(String disp) { - this.displayMode = disp; - } - public String getDisplayMode(){ - return this.displayMode; - } - - public void switchDisplayMode() { - if (displayMode.equals("binary")) { - displayMode = "octal"; - } else if (displayMode.equals("octal")) { - displayMode = "decimal"; - } else if (displayMode.equals("decimal")) { - displayMode = "hexadecimal"; - } else { - displayMode = "binary"; - } - } - - public void switchDisplayMode(String mode) { - displayMode = mode; - } - - public double a; - - // Store Memory - public void storeMemory(double mem) { - this.a = mem; - } - - // Clear Memory - public void clearMemory() { - this.a = Double.NaN; - } - - // Recall Memory - public double memoryRecall(){ - return this.a; - } } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java index 32b97348..afdab984 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/OperationsTest.java @@ -163,8 +163,8 @@ public void inverseNums() { // Switch Signs @Test public void switchSigns() { - double expected = -8; - double actual = operations.switchSign(8); + double expected = 8; + double actual = operations.switchSign(-8); assertEquals(expected, actual, 0.01); } From deef71e5910a4c1bd05a944eaeae4d7d690841f8 Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sun, 9 Feb 2020 14:56:58 -0500 Subject: [PATCH 22/37] added back some code --- .../scientificcalculator/ScientificCalc.java | 59 ++++++++++++++++++- 1 file changed, 58 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index bb485730..a35336b6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -78,6 +78,63 @@ public double toDegrees (double num1) { return toDegrees (num1); } - + // Units Mode + public String unitsMode; + + public void switchUnitsMode(){ + if (unitsMode.equals("Degrees")) { + unitsMode = "Radians"; + } + else { + unitsMode = "Degrees"; + } + } + + public void switchUnitsMode (String mode) { + unitsMode = mode; + } + + // Display Mode + public String displayMode; + + public void setDisplayMode(String disp) { + this.displayMode = disp; + } + public String getDisplayMode(){ + return this.displayMode; + } + + public void switchDisplayMode() { + if (displayMode.equals("binary")) { + displayMode = "octal"; + } else if (displayMode.equals("octal")) { + displayMode = "decimal"; + } else if (displayMode.equals("decimal")) { + displayMode = "hexadecimal"; + } else { + displayMode = "binary"; + } + } + + public void switchDisplayMode(String mode) { + displayMode = mode; + } + + public double a; + + // Store Memory + public void storeMemory(double mem) { + this.a = mem; + } + + // Clear Memory + public void clearMemory() { + this.a = Double.NaN; + } + + // Recall Memory + public double memoryRecall(){ + return this.a; + } } From 583158c60669271b1988301a899031032c10317c Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 15:32:49 -0500 Subject: [PATCH 23/37] update --- .../scientificcalculator/Display.java | 4 +- .../scientificcalculator/MainApplication.java | 84 +++++++++++++------ 2 files changed, 58 insertions(+), 30 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 2a3f07f0..a54ac971 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -2,9 +2,7 @@ public class Display { public boolean checkState = true; - public static double total = 0; - public static double currentTotal = 0; - public static boolean error; + public static boolean error = false; public void displayValue(double input){ diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 9f590e4e..2f817487 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -7,8 +7,7 @@ public class MainApplication { public static void main(String[] args) { - - + double input; double total = 0; double currentTotal = 0; @@ -37,46 +36,77 @@ public static void main(String[] args) { display.clearDisplay(); break; case 1: - currentTotal = opp.add(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); - total = currentTotal; + if(!Display.error) { + currentTotal = opp.add(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } break; case 2: - currentTotal = opp.subtract(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); - total = currentTotal; + if(!Display.error) { + currentTotal = opp.subtract(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } break; case 3: - currentTotal = opp.multiply(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); - total = currentTotal; + if(!Display.error) { + currentTotal = opp.multiply(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } break; case 4: - currentTotal = opp.divide(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); - total = currentTotal; + if(!Display.error) { + currentTotal = opp.divide(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } break; case 5: - currentTotal = opp.square(total); - display.displayValue(currentTotal); - total = currentTotal; + if(!Display.error) { + currentTotal = opp.square(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } break; case 6: - currentTotal = opp.squareRoot(total); - display.displayValue(currentTotal); - total = currentTotal; + if(!Display.error) { + currentTotal = opp.squareRoot(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } break; case 7: - currentTotal = opp.exponent(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); - total = currentTotal; + if(!Display.error) { + currentTotal = opp.exponent(total, Console.getDoubleInput("Please enter a number:")); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } break; case 8: - currentTotal = opp.inverse(total); - display.displayValue(currentTotal); - total = currentTotal; + if(!Display.error) { + currentTotal = opp.inverse(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } break; - } } From 693884ce522640ddb08cc088c112aad9a7abb5fa Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 15:34:21 -0500 Subject: [PATCH 24/37] update again --- .../zipcodewilmington/scientificcalculator/Display.java | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index a54ac971..792dd7a0 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -16,15 +16,13 @@ public void displayCurrentValue(double input) { public void clearDisplay() { checkState = true; - total = 0; - currentTotal = 0; - displayValue(total); + displayValue(0); error = false; } public void changeNumberDisplay(double nextInput) { - total = nextInput; - System.out.println(total); +// total = nextInput; +// System.out.println(total); } public void displayErr() { //if math calculations don't work, display 'Err') From 1ebf544c22db0ee2127ba0e47de3eb75c2040764 Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 16:11:04 -0500 Subject: [PATCH 25/37] added all fucntions to logic --- .../scientificcalculator/Console.java | 24 ++++- .../scientificcalculator/MainApplication.java | 101 +++++++++++++++++- .../scientificcalculator/ScientificCalc.java | 4 +- 3 files changed, 125 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 8a1f3323..b3a1f9c1 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -70,10 +70,32 @@ public static int getOperand(String prompt){ return 5; }else if(nextOperand.equalsIgnoreCase("sqrt")){ return 6; - }else if(nextOperand.equalsIgnoreCase("x^x")){ + }else if(nextOperand.equalsIgnoreCase("x^n")){ return 7; }else if(nextOperand.equalsIgnoreCase("1/x")){ return 8; + }else if(nextOperand.equalsIgnoreCase("+/-")){ + return 9; + }else if(nextOperand.equalsIgnoreCase("sin")){ + return 10; + }else if(nextOperand.equalsIgnoreCase("cos")){ + return 11; + }else if(nextOperand.equalsIgnoreCase("tan")){ + return 12; + }else if(nextOperand.equalsIgnoreCase("invSin")){ + return 13; + }else if(nextOperand.equalsIgnoreCase("invCos")){ + return 14; + }else if(nextOperand.equalsIgnoreCase("invTan")){ + return 15; + }else if(nextOperand.equalsIgnoreCase("log")){ + return 16; + }else if(nextOperand.equalsIgnoreCase("invLog")){ + return 17; + }else if(nextOperand.equalsIgnoreCase("Ln")){ + return 18; + }else if(nextOperand.equalsIgnoreCase("invLn")){ + return 19; }else if(nextOperand.equalsIgnoreCase("c")){ return 0; }else if(nextOperand.equalsIgnoreCase("off")){ diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 2f817487..6c1369b4 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -14,7 +14,7 @@ public static void main(String[] args) { int operand; Display display = new Display(); Operations opp = new Operations(); - double firstDouble; + ScientificCalc sci = new ScientificCalc(); boolean on = true; Console.println("Welcome to my calculator!"); @@ -107,6 +107,105 @@ public static void main(String[] args) { display.displayErr(); } break; + case 9: + if(!Display.error) { + currentTotal = opp.switchSign(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 10: + if(!Display.error) { + currentTotal = sci.sin(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 11: + if(!Display.error) { + currentTotal = sci.cos(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 12: + if(!Display.error) { + currentTotal = sci.tan(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 13: + if(!Display.error) { + currentTotal = sci.inverseSin(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 14: + if(!Display.error) { + currentTotal = sci.inverseCos(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 15: + if(!Display.error) { + currentTotal = sci.inverseTan(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 16: + if(!Display.error) { + currentTotal = sci.logarithm(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 17: + if(!Display.error) { + currentTotal = sci.inverseLog(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 18: + if(!Display.error) { + currentTotal = sci.naturalLog(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; + case 19: + if(!Display.error) { + currentTotal = sci.inverseNaturalLog(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index a35336b6..e38375ca 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -54,7 +54,7 @@ public double naturalLog (double num1) { } // Inverse Natural Log - public double inverseNaturalLog (double num1) { + public double inverseNaturalLog (double num1) { return Math.pow(10, num1); } @@ -135,6 +135,6 @@ public void clearMemory() { // Recall Memory public double memoryRecall(){ return this.a; - } + }*/ } From ff86ccd2bf4d097a66137f11817b433e0e92c2a7 Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sun, 9 Feb 2020 16:15:11 -0500 Subject: [PATCH 26/37] removed useless code --- .../scientificcalculator/Display.java | 2 +- .../scientificcalculator/Operations.java | 5 +- .../scientificcalculator/ScientificCalc.java | 70 ------------------- 3 files changed, 3 insertions(+), 74 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 2a3f07f0..fe66639a 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -28,7 +28,7 @@ public void changeNumberDisplay(double nextInput) { total = nextInput; System.out.println(total); } - public void displayErr() { + public static void displayErr() { //if math calculations don't work, display 'Err') error = true; System.out.println("Err. Clear screen."); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java index 87328ef8..59810d40 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Operations.java @@ -33,9 +33,8 @@ public double square (double num1) { } // Square Root of Number - public double squareRoot (double num1) { - return sqrt(num1); - } + public double squareRoot (double num1) { return sqrt(num1); } + // Exponent public double exponent (double num1, double num2) { diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index a35336b6..1f362d39 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -67,74 +67,4 @@ public int factorial (int num1) { return sum; } - /* - // Switch Between Radians and Degrees - public double toRadians (double num1) { - return toRadians (num1); - } - - // Switch Between Radians and Degrees - public double toDegrees (double num1) { - return toDegrees (num1); - } - - // Units Mode - public String unitsMode; - - public void switchUnitsMode(){ - if (unitsMode.equals("Degrees")) { - unitsMode = "Radians"; - } - else { - unitsMode = "Degrees"; - } - } - - public void switchUnitsMode (String mode) { - unitsMode = mode; - } - - // Display Mode - public String displayMode; - - public void setDisplayMode(String disp) { - this.displayMode = disp; - } - public String getDisplayMode(){ - return this.displayMode; - } - - public void switchDisplayMode() { - if (displayMode.equals("binary")) { - displayMode = "octal"; - } else if (displayMode.equals("octal")) { - displayMode = "decimal"; - } else if (displayMode.equals("decimal")) { - displayMode = "hexadecimal"; - } else { - displayMode = "binary"; - } - } - - public void switchDisplayMode(String mode) { - displayMode = mode; - } - - public double a; - - // Store Memory - public void storeMemory(double mem) { - this.a = mem; - } - - // Clear Memory - public void clearMemory() { - this.a = Double.NaN; - } - - // Recall Memory - public double memoryRecall(){ - return this.a; - } - } From 1e65ad6aff72bac8a2bcaa3bdaa62c1252a13986 Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sun, 9 Feb 2020 16:26:48 -0500 Subject: [PATCH 27/37] added methods for conversion from radians to degrees --- .../scientificcalculator/ScientificCalc.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index 67787b8e..c6118914 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -67,4 +67,16 @@ public int factorial (int num1) { return sum; } + // Degrees to Radians + + public Double radian(Double num1){ + return toRadians(num1); + } + + // Radians to Degrees + public Double degree(Double num1){ + return toDegrees(num1); + } + + } From a6a2a15c4e2dff46acd9eecb4f2b287f7e123899 Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sun, 9 Feb 2020 17:11:17 -0500 Subject: [PATCH 28/37] added methods for radians and displays --- .../scientificcalculator/ScientificCalc.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index c6118914..85428006 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -78,5 +78,15 @@ public Double degree(Double num1){ return toDegrees(num1); } + // Ghetto Switch Display Mode + public static String Hexadecimal(Integer input) { + return Integer.toHexString(input); + } + public static String Octal(Integer input) { + return Integer.toOctalString(input); + } + public static String Binary(Integer input) { + return Integer.toBinaryString(input); + } } From 1757d788935d3c6b64571626408a1a8c0c14b7bd Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 17:15:16 -0500 Subject: [PATCH 29/37] update --- .../scientificcalculator/Console.java | 25 +++++++++-- .../scientificcalculator/Display.java | 33 +++++++++++++-- .../scientificcalculator/MainApplication.java | 41 ++++++++++++++++++- .../scientificcalculator/ScientificCalc.java | 8 ++-- 4 files changed, 94 insertions(+), 13 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index b3a1f9c1..7549515e 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -29,11 +29,20 @@ public static String getStringInput(String prompt) { return "Hello there " + userInput + "!"; } - public static Integer getIntegerInput() { + public static int getIntegerInput(String prompt) { + + int userInput; scanner = new Scanner(System.in); - Integer userInput = scanner.nextInt(); - return userInput; + println(prompt); + String nextNum = scanner.nextLine(); + + try{ + userInput = Integer.parseInt(nextNum); + return userInput; + }catch (Exception e) { + return Console.getIntegerInput(prompt); + } } public static Double getDoubleInput(String prompt) { @@ -48,7 +57,7 @@ public static Double getDoubleInput(String prompt) { userInput = Double.parseDouble(nextNum); return userInput; }catch (Exception e) { - return Console.getDoubleInput("Please enter a number:"); + return Console.getDoubleInput(prompt); } } @@ -96,6 +105,14 @@ public static int getOperand(String prompt){ return 18; }else if(nextOperand.equalsIgnoreCase("invLn")){ return 19; + }else if(nextOperand.equalsIgnoreCase("!")){ + return 20; + }else if(nextOperand.equalsIgnoreCase("m+")){ + return 21; + }else if(nextOperand.equalsIgnoreCase("mc")){ + return 22; + }else if(nextOperand.equalsIgnoreCase("mrc")){ + return 23; }else if(nextOperand.equalsIgnoreCase("c")){ return 0; }else if(nextOperand.equalsIgnoreCase("off")){ diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 1a8d0fc5..c87791c3 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -3,7 +3,7 @@ public class Display { public boolean checkState = true; public static boolean error = false; - + public int displayMode = 0; public void displayValue(double input){ System.out.println(input); @@ -20,10 +20,35 @@ public void clearDisplay() { error = false; } - public void changeNumberDisplay(double nextInput) { -// total = nextInput; -// System.out.println(total); + public void changeNumberDisplay() { + + String output; + switch (displayMode){ + case 0: + System.out.println(MainApplication.total); + displayMode++; + break; + case 1: + output = Double.toHexString(MainApplication.total); + System.out.println(output); + displayMode++; + break; + case 2: + + output = Integer.toBinaryString(MainApplication.total); + System.out.println(output); + displayMode++; + break; + case 3: + + break; + } } + + public void changeNumberDisplay(String mode) { + + } + public static void displayErr() { //if math calculations don't work, display 'Err') error = true; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 6c1369b4..9db8cba1 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -6,10 +6,11 @@ */ public class MainApplication { + public static double total = 0; + public static void main(String[] args) { double input; - double total = 0; double currentTotal = 0; int operand; Display display = new Display(); @@ -17,7 +18,7 @@ public static void main(String[] args) { ScientificCalc sci = new ScientificCalc(); boolean on = true; - Console.println("Welcome to my calculator!"); + Console.println("Welcome to Mav!"); String name = Console.getStringInput("Please enter your name!"); Console.println(name); String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^x , 1/x, c, off"; @@ -206,6 +207,42 @@ public static void main(String[] args) { display.displayErr(); } break; + case 20: + if(!Display.error) { + currentTotal = sci.factorial(total); + display.displayValue(currentTotal); + total = currentTotal; + }else{ + display.displayErr(); + } + break; +// case 21: +// if(!Display.error) { +// currentTotal = sci.inverseNaturalLog(total); +// display.displayValue(currentTotal); +// total = currentTotal; +// }else{ +// display.displayErr(); +// } +// break; +// case 22: +// if(!Display.error) { +// currentTotal = sci.inverseNaturalLog(total); +// display.displayValue(currentTotal); +// total = currentTotal; +// }else{ +// display.displayErr(); +// } +// break; +// case 23: +// if(!Display.error) { +// currentTotal = sci.inverseNaturalLog(total); +// display.displayValue(currentTotal); +// total = currentTotal; +// }else{ +// display.displayErr(); +// } +// break; } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index 67787b8e..93f2d531 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -59,9 +59,11 @@ public double inverseNaturalLog (double num1) { } // Factorial - public int factorial (int num1) { - int sum = 1; - for (int i = 2; i <= num1 ; i++) { + public double factorial (double num1) { + + int intNum1 = (int) Math.round(num1); + double sum = 1.0; + for (int i = 2; i <= intNum1 ; i++) { sum *= i; } return sum; From 5181f60d1aa30b720ee8a6d0b7a6c960db692d77 Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sun, 9 Feb 2020 17:34:07 -0500 Subject: [PATCH 30/37] had to change names of methods to account for importing Math library --- .../scientificcalculator/MainApplication.java | 6 +++--- .../scientificcalculator/ScientificCalc.java | 6 +++--- .../scientific_calculator/ScientificTests.java | 6 +++--- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 6c1369b4..c6d55f24 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -118,7 +118,7 @@ public static void main(String[] args) { break; case 10: if(!Display.error) { - currentTotal = sci.sin(total); + currentTotal = sci.sine(total); display.displayValue(currentTotal); total = currentTotal; }else{ @@ -127,7 +127,7 @@ public static void main(String[] args) { break; case 11: if(!Display.error) { - currentTotal = sci.cos(total); + currentTotal = sci.cose(total); display.displayValue(currentTotal); total = currentTotal; }else{ @@ -136,7 +136,7 @@ public static void main(String[] args) { break; case 12: if(!Display.error) { - currentTotal = sci.tan(total); + currentTotal = sci.tangent(total); display.displayValue(currentTotal); total = currentTotal; }else{ diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index 85428006..1b1b8936 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -7,17 +7,17 @@ public class ScientificCalc { // Trig Functions // Sine - public double sin (double num1) { + public double sine (double num1) { return sin( num1 ); } // Cosine - public double cos (double num1) { + public double cose (double num1) { return cos( num1 ); } // Tangent - public double tan (double num1) { + public double tangent (double num1) { return tan( num1 ); } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java index d3d20abd..92504af7 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java @@ -13,7 +13,7 @@ public class ScientificTests { @Test public void sinRadians() { double expected = 0; - double actual = scientific.sin(0); + double actual = scientific.sine(0); assertEquals(expected, actual, 0.01); } @@ -30,7 +30,7 @@ public void sinDegrees() { @Test public void cosRadians() { double expected = 1; - double actual = scientific.cos(0); + double actual = scientific.cose(0); assertEquals(expected, actual, 0.01); } @@ -47,7 +47,7 @@ public void cosDegrees() { @Test public void tanRadians() { double expected = 0; - double actual = scientific.tan(0); + double actual = scientific.tangent(0); assertEquals(expected, actual, 0.01); } From 272f5b698691d07a7cdd98bda78fc4a17b805fae Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 17:36:05 -0500 Subject: [PATCH 31/37] updated display --- .../scientificcalculator/Display.java | 24 ++++++++++++------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index c87791c3..77013d37 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -22,31 +22,39 @@ public void clearDisplay() { } public void changeNumberDisplay() { - String output; + int intTotal = (int) Math.round(MainApplication.total); switch (displayMode){ case 0: - System.out.println(MainApplication.total); + System.out.println(intTotal); displayMode++; break; case 1: - output = Double.toHexString(MainApplication.total); - System.out.println(output); + System.out.println(ScientificCalc.Hexadecimal(intTotal)); displayMode++; break; case 2: - - output = Integer.toBinaryString(MainApplication.total); - System.out.println(output); + System.out.println(ScientificCalc.Octal(intTotal)); displayMode++; break; case 3: - + System.out.println(ScientificCalc.Binary(intTotal)); + displayMode = 0; break; } } public void changeNumberDisplay(String mode) { + int intTotal = (int) Math.round(MainApplication.total); + if(mode.equalsIgnoreCase("hexa")){ + System.out.println(ScientificCalc.Hexadecimal(intTotal)); + }else if(mode.equalsIgnoreCase("binary")) { + System.out.println(ScientificCalc.Binary(intTotal)); + }else if(mode.equalsIgnoreCase("octal")){ + System.out.println(ScientificCalc.Octal(intTotal)); + }else{ + System.out.println(intTotal); + } } public static void displayErr() { From 0c5f44da122aa791a2e5e01aff52f3058a5cce92 Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 18:37:50 -0500 Subject: [PATCH 32/37] update main --- .../scientificcalculator/Console.java | 8 ++ .../scientificcalculator/Display.java | 32 +++++++- .../scientificcalculator/MainApplication.java | 82 ++++++++++++------- .../scientificcalculator/ScientificCalc.java | 22 ++++- 4 files changed, 111 insertions(+), 33 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 7549515e..817a7bf0 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -113,6 +113,14 @@ public static int getOperand(String prompt){ return 22; }else if(nextOperand.equalsIgnoreCase("mrc")){ return 23; + }else if(nextOperand.equalsIgnoreCase("switch")){ + return 24; + }else if(nextOperand.equalsIgnoreCase("switch x")){ + return 25; + }else if(nextOperand.equalsIgnoreCase("rd")){ + return 26; + }else if(nextOperand.equalsIgnoreCase("rd x")){ + return 27; }else if(nextOperand.equalsIgnoreCase("c")){ return 0; }else if(nextOperand.equalsIgnoreCase("off")){ diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 77013d37..4893dfcf 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -1,9 +1,12 @@ package com.zipcodewilmington.scientificcalculator; +import sun.applet.Main; + public class Display { public boolean checkState = true; public static boolean error = false; public int displayMode = 0; + public int unitMode = 0; public void displayValue(double input){ System.out.println(input); @@ -52,8 +55,35 @@ public void changeNumberDisplay(String mode) { System.out.println(ScientificCalc.Binary(intTotal)); }else if(mode.equalsIgnoreCase("octal")){ System.out.println(ScientificCalc.Octal(intTotal)); - }else{ + }else if(mode.equalsIgnoreCase("deci")){ System.out.println(intTotal); + }else{ + Display.displayErr(); + } + } + + public void changeUnitDisplay(){ + + switch (unitMode){ + case 0: + System.out.println(ScientificCalc.radian(MainApplication.total)); + unitMode++; + break; + case 1: + System.out.println(ScientificCalc.degree(MainApplication.total)); + unitMode = 0; + break; + } + } + + public void changeUnitDisplay(String unit){ + + if(unit.equalsIgnoreCase("rad")){ + System.out.println(ScientificCalc.radian(MainApplication.total)); + }else if(unit.equalsIgnoreCase("deg")){ + System.out.println(ScientificCalc.degree(MainApplication.total)); + }else { + Display.displayErr(); } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index d4a0df90..6db1535c 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -7,11 +7,10 @@ public class MainApplication { public static double total = 0; - + public static double currentTotal = 0; public static void main(String[] args) { double input; - double currentTotal = 0; int operand; Display display = new Display(); Operations opp = new Operations(); @@ -26,6 +25,7 @@ public static void main(String[] args) { if(display.checkState){ input = Console.getDoubleInput("Please enter a number:"); total = input; + currentTotal = input; display.checkState = false; }else { operand = Console.getOperand(operandPrompt); @@ -216,33 +216,57 @@ public static void main(String[] args) { display.displayErr(); } break; -// case 21: -// if(!Display.error) { -// currentTotal = sci.inverseNaturalLog(total); -// display.displayValue(currentTotal); -// total = currentTotal; -// }else{ -// display.displayErr(); -// } -// break; -// case 22: -// if(!Display.error) { -// currentTotal = sci.inverseNaturalLog(total); -// display.displayValue(currentTotal); -// total = currentTotal; -// }else{ -// display.displayErr(); -// } -// break; -// case 23: -// if(!Display.error) { -// currentTotal = sci.inverseNaturalLog(total); -// display.displayValue(currentTotal); -// total = currentTotal; -// }else{ -// display.displayErr(); -// } -// break; + case 21: + if(!Display.error) { + ScientificCalc.memoryAddDouble(); + }else{ + display.displayErr(); + } + break; + case 22: + if(!Display.error) { + ScientificCalc.memoryReset(); + }else{ + display.displayErr(); + } + break; + case 23: + if(!Display.error) { + display.displayValue(ScientificCalc.memDouble); + }else{ + display.displayErr(); + } + break; + case 24: + if(!Display.error) { + display.changeNumberDisplay(); + }else{ + display.displayErr(); + } + break; + case 25: + if(!Display.error) { + String mode = Console.getStringInput("Enter mode: (Deci, Hexa, Binary, Octal"); + display.changeNumberDisplay(mode); + }else{ + display.displayErr(); + } + break; + case 26: + if(!Display.error) { + display.changeUnitDisplay(); + }else{ + display.displayErr(); + } + break; + case 27: + if(!Display.error) { + String unit = Console.getStringInput("Enter mod: rad, deg"); + display.changeUnitDisplay(unit); + }else{ + display.displayErr(); + } + break; } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index 260ae477..1adc1b23 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -4,8 +4,8 @@ public class ScientificCalc { + public static double memDouble; // Trig Functions - // Sine public double sine (double num1) { return sin( num1 ); @@ -71,12 +71,12 @@ public double factorial (double num1) { // Degrees to Radians - public Double radian(Double num1){ + public static double radian(double num1){ return toRadians(num1); } // Radians to Degrees - public Double degree(Double num1){ + public static double degree(double num1){ return toDegrees(num1); } @@ -91,4 +91,20 @@ public static String Binary(Integer input) { return Integer.toBinaryString(input); } + public static void memoryAddDouble(){ + + memDouble = MainApplication.currentTotal; + + } + + public static void memoryReset(){ + + memDouble = 0; + + } + + public static double getMemoryDouble(){ + + return memDouble; + } } From 9d0fe091dfed547e9acbf4e0097e79f810c321cc Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Sun, 9 Feb 2020 18:39:34 -0500 Subject: [PATCH 33/37] added 2 new unique features --- .../scientificcalculator/ScientificCalc.java | 26 ++++++++++++++++--- .../ScientificTests.java | 19 +++++++++++--- 2 files changed, 39 insertions(+), 6 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index 1b1b8936..2ce62e6d 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -45,7 +45,7 @@ public double logarithm (double num1) { // Inverse Logarithm public double inverseLog (double num1) { - return exp(num1); + return pow(10,num1); } // Natural Log @@ -55,7 +55,7 @@ public double naturalLog (double num1) { // Inverse Natural Log public double inverseNaturalLog (double num1) { - return Math.pow(10, num1); + return exp(num1); } // Factorial @@ -67,8 +67,28 @@ public int factorial (int num1) { return sum; } - // Degrees to Radians + // Monthly Interest Calc + public double yearlyInterest (double principal, double interestRate) { + double amount = principal * (1 + (interestRate/100)) - principal; + return amount; + } + + // First input is take in a principal amount and then the rate is a percentage + // IsPrime + public boolean isPrime(double num) { + if (num <= 1) { + return false; + } + for (double i = 2; i <= sqrt(num); i++) { + if (num % i == 0) { + return false; + } + } + return true; + } + + // Degrees to Radians public Double radian(Double num1){ return toRadians(num1); } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java index 92504af7..a74a6885 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/ScientificTests.java @@ -124,8 +124,8 @@ public void log () { // Inverse Log @Test public void inverseLog () { - double expected = 1; - double actual = scientific.inverseLog(0); + double expected = 100; + double actual = scientific.inverseLog(2); assertEquals(expected, actual, 0.01); } @@ -138,7 +138,12 @@ public void naturalLog () { } // Inverse Natural Log - + @Test + public void inverseNaturalLog() { + double expected = 1; + double actual = scientific.inverseNaturalLog(0); + assertEquals(expected, actual, 0.01); + } // Factorial @Test @@ -148,4 +153,12 @@ public void factorial () { assertEquals(expected, actual, 0.01); } + // Simple Yearly Interest Calc + @Test + public void yearlyInterest () { + double expected = 50; + double actual = scientific.yearlyInterest(1000, 5); + assertEquals(expected, actual, 0.01); + } + } From 5a61514050edd6a8100cd81d5c7d42a5d628aee5 Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 18:48:54 -0500 Subject: [PATCH 34/37] fixed merge --- .../scientificcalculator/ScientificCalc.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java index 96c813a9..bcca9233 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/ScientificCalc.java @@ -89,6 +89,12 @@ public boolean isPrime(double num) { return true; } + // Degrees to Radians + + public static double radian(double num1){ + return toRadians(num1); + } + // Radians to Degrees public static double degree(double num1){ return toDegrees(num1); From 0c587d98cb7a7722929cae4d17df7c8bf4983a69 Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 19:36:00 -0500 Subject: [PATCH 35/37] near the end --- .../scientificcalculator/Console.java | 4 + .../scientificcalculator/MainApplication.java | 79 ++++++++++++------- 2 files changed, 54 insertions(+), 29 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 817a7bf0..2db1e5dd 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -121,6 +121,10 @@ public static int getOperand(String prompt){ return 26; }else if(nextOperand.equalsIgnoreCase("rd x")){ return 27; + }else if(nextOperand.equalsIgnoreCase("prime")){ + return 28; + }else if(nextOperand.equalsIgnoreCase("year%")){ + return 29; }else if(nextOperand.equalsIgnoreCase("c")){ return 0; }else if(nextOperand.equalsIgnoreCase("off")){ diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 6db1535c..29323938 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -20,7 +20,7 @@ public static void main(String[] args) { Console.println("Welcome to Mav!"); String name = Console.getStringInput("Please enter your name!"); Console.println(name); - String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^x , 1/x, c, off"; + String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^n , 1/x, c, off"; while (on){ if(display.checkState){ input = Console.getDoubleInput("Please enter a number:"); @@ -42,7 +42,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 2: @@ -51,7 +51,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 3: @@ -60,7 +60,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 4: @@ -69,7 +69,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 5: @@ -78,7 +78,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 6: @@ -87,7 +87,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 7: @@ -96,7 +96,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 8: @@ -105,7 +105,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 9: @@ -114,7 +114,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 10: @@ -123,7 +123,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 11: @@ -132,7 +132,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 12: @@ -141,7 +141,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 13: @@ -150,7 +150,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 14: @@ -159,7 +159,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 15: @@ -168,7 +168,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 16: @@ -177,7 +177,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 17: @@ -186,7 +186,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 18: @@ -195,7 +195,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 19: @@ -204,7 +204,7 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 20: @@ -213,35 +213,35 @@ public static void main(String[] args) { display.displayValue(currentTotal); total = currentTotal; }else{ - display.displayErr(); + Display.displayErr(); } break; case 21: if(!Display.error) { ScientificCalc.memoryAddDouble(); }else{ - display.displayErr(); + Display.displayErr(); } break; case 22: if(!Display.error) { ScientificCalc.memoryReset(); }else{ - display.displayErr(); + Display.displayErr(); } break; case 23: if(!Display.error) { - display.displayValue(ScientificCalc.memDouble); + display.displayValue(ScientificCalc.getMemoryDouble()); }else{ - display.displayErr(); + Display.displayErr(); } break; case 24: if(!Display.error) { display.changeNumberDisplay(); }else{ - display.displayErr(); + Display.displayErr(); } break; case 25: @@ -249,14 +249,14 @@ public static void main(String[] args) { String mode = Console.getStringInput("Enter mode: (Deci, Hexa, Binary, Octal"); display.changeNumberDisplay(mode); }else{ - display.displayErr(); + Display.displayErr(); } break; case 26: if(!Display.error) { display.changeUnitDisplay(); }else{ - display.displayErr(); + Display.displayErr(); } break; case 27: @@ -264,7 +264,28 @@ public static void main(String[] args) { String unit = Console.getStringInput("Enter mod: rad, deg"); display.changeUnitDisplay(unit); }else{ - display.displayErr(); + Display.displayErr(); + } + break; + case 28: + if(!Display.error) { + if(sci.isPrime(total)){ + System.out.println("It's a prime!"); + }else { + System.out.println("It's not a prime!"); + } + }else{ + Display.displayErr(); + } + break; + case 29: + if(!Display.error) { + double principal = Console.getDoubleInput("Enter principal:"); + double interest = Console.getDoubleInput("Enter interest:"); + double yearInterest = sci.yearlyInterest(principal, interest); + display.displayValue(yearInterest); + }else{ + Display.displayErr(); } break; } From b6b839cf3e894cf709067cc08fea3afa11dc6c49 Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 21:37:58 -0500 Subject: [PATCH 36/37] BIG UI UPDATE --- .../scientificcalculator/Console.java | 4 +- .../scientificcalculator/Display.java | 44 ++++++++++++----- .../scientificcalculator/MainApplication.java | 48 +++++++++---------- .../scientific_calculator/DisplayTest.java | 44 +++++++++++++++++ 4 files changed, 101 insertions(+), 39 deletions(-) create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/DisplayTest.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 2db1e5dd..cf89ae24 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -113,9 +113,9 @@ public static int getOperand(String prompt){ return 22; }else if(nextOperand.equalsIgnoreCase("mrc")){ return 23; - }else if(nextOperand.equalsIgnoreCase("switch")){ + }else if(nextOperand.equalsIgnoreCase("mode")){ return 24; - }else if(nextOperand.equalsIgnoreCase("switch x")){ + }else if(nextOperand.equalsIgnoreCase("mode x")){ return 25; }else if(nextOperand.equalsIgnoreCase("rd")){ return 26; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index 4893dfcf..b46014d0 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -7,10 +7,6 @@ public class Display { public static boolean error = false; public int displayMode = 0; public int unitMode = 0; - public void displayValue(double input){ - - System.out.println(input); - } public void displayCurrentValue(double input) { System.out.println(input); @@ -19,7 +15,7 @@ public void displayCurrentValue(double input) { public void clearDisplay() { checkState = true; - displayValue(0); + update(0); error = false; } @@ -50,13 +46,13 @@ public void changeNumberDisplay(String mode) { int intTotal = (int) Math.round(MainApplication.total); if(mode.equalsIgnoreCase("hexa")){ - System.out.println(ScientificCalc.Hexadecimal(intTotal)); + update(Double.parseDouble(ScientificCalc.Hexadecimal(intTotal))); }else if(mode.equalsIgnoreCase("binary")) { - System.out.println(ScientificCalc.Binary(intTotal)); + update(Double.parseDouble(ScientificCalc.Binary(intTotal))); }else if(mode.equalsIgnoreCase("octal")){ - System.out.println(ScientificCalc.Octal(intTotal)); + update(Double.parseDouble(ScientificCalc.Octal(intTotal))); }else if(mode.equalsIgnoreCase("deci")){ - System.out.println(intTotal); + update(intTotal); }else{ Display.displayErr(); } @@ -66,11 +62,11 @@ public void changeUnitDisplay(){ switch (unitMode){ case 0: - System.out.println(ScientificCalc.radian(MainApplication.total)); + update(ScientificCalc.radian(MainApplication.total)); unitMode++; break; case 1: - System.out.println(ScientificCalc.degree(MainApplication.total)); + update(ScientificCalc.degree(MainApplication.total)); unitMode = 0; break; } @@ -79,9 +75,9 @@ public void changeUnitDisplay(){ public void changeUnitDisplay(String unit){ if(unit.equalsIgnoreCase("rad")){ - System.out.println(ScientificCalc.radian(MainApplication.total)); + update(ScientificCalc.radian(MainApplication.total)); }else if(unit.equalsIgnoreCase("deg")){ - System.out.println(ScientificCalc.degree(MainApplication.total)); + update(ScientificCalc.degree(MainApplication.total)); }else { Display.displayErr(); } @@ -93,4 +89,26 @@ public static void displayErr() { System.out.println("Err. Clear screen."); } + public void update(double update){ + String[][] calc = { {"C", " RD", "RD X ", " SIN", "invSin", "Off"}, + {"+", "X^2", " Sqrt", " COS", "invCos", " "}, + {"-", "X^N", " 1/x ", " TAN", "invTan", " "}, + {"*", " M+", "Prime", " Log", "invLog", " "}, + {"/", " MC", "Year%", " Ln ", " invLn", " "}, + {"!", "MRC", " +/- ", "Mode", "Mode X", " "}}; + + String dis = String.format("|%27s| ", update); + + System.out.println("-----------------------------"); + System.out.println(dis); + System.out.println("-----------------------------"); + for(int i = 0; i < calc.length; i++){ + for (int j = 0; j < calc.length; j++){ + System.out.print("|" + calc[i][j]); + } + System.out.print("|"); + System.out.println(); + System.out.println(" - --- ----- ---- ------ ---"); + } + } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 29323938..02d0cab6 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -20,15 +20,15 @@ public static void main(String[] args) { Console.println("Welcome to Mav!"); String name = Console.getStringInput("Please enter your name!"); Console.println(name); - String operandPrompt = "Choose an operand: + , - , * , / , x^2 , sqrt , x^n , 1/x, c, off"; while (on){ if(display.checkState){ + display.update(0); input = Console.getDoubleInput("Please enter a number:"); total = input; currentTotal = input; display.checkState = false; }else { - operand = Console.getOperand(operandPrompt); + operand = Console.getOperand("Enter an operator:"); switch (operand){ case 100: on = false; @@ -39,7 +39,7 @@ public static void main(String[] args) { case 1: if(!Display.error) { currentTotal = opp.add(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -48,7 +48,7 @@ public static void main(String[] args) { case 2: if(!Display.error) { currentTotal = opp.subtract(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -57,7 +57,7 @@ public static void main(String[] args) { case 3: if(!Display.error) { currentTotal = opp.multiply(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -66,7 +66,7 @@ public static void main(String[] args) { case 4: if(!Display.error) { currentTotal = opp.divide(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -75,7 +75,7 @@ public static void main(String[] args) { case 5: if(!Display.error) { currentTotal = opp.square(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -84,7 +84,7 @@ public static void main(String[] args) { case 6: if(!Display.error) { currentTotal = opp.squareRoot(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -93,7 +93,7 @@ public static void main(String[] args) { case 7: if(!Display.error) { currentTotal = opp.exponent(total, Console.getDoubleInput("Please enter a number:")); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -102,7 +102,7 @@ public static void main(String[] args) { case 8: if(!Display.error) { currentTotal = opp.inverse(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -111,7 +111,7 @@ public static void main(String[] args) { case 9: if(!Display.error) { currentTotal = opp.switchSign(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -120,7 +120,7 @@ public static void main(String[] args) { case 10: if(!Display.error) { currentTotal = sci.sine(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -129,7 +129,7 @@ public static void main(String[] args) { case 11: if(!Display.error) { currentTotal = sci.cose(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -138,7 +138,7 @@ public static void main(String[] args) { case 12: if(!Display.error) { currentTotal = sci.tangent(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -147,7 +147,7 @@ public static void main(String[] args) { case 13: if(!Display.error) { currentTotal = sci.inverseSin(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -156,7 +156,7 @@ public static void main(String[] args) { case 14: if(!Display.error) { currentTotal = sci.inverseCos(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -165,7 +165,7 @@ public static void main(String[] args) { case 15: if(!Display.error) { currentTotal = sci.inverseTan(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -174,7 +174,7 @@ public static void main(String[] args) { case 16: if(!Display.error) { currentTotal = sci.logarithm(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -183,7 +183,7 @@ public static void main(String[] args) { case 17: if(!Display.error) { currentTotal = sci.inverseLog(total); - display.displayValue(currentTotal); + display.update( currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -192,7 +192,7 @@ public static void main(String[] args) { case 18: if(!Display.error) { currentTotal = sci.naturalLog(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -201,7 +201,7 @@ public static void main(String[] args) { case 19: if(!Display.error) { currentTotal = sci.inverseNaturalLog(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -210,7 +210,7 @@ public static void main(String[] args) { case 20: if(!Display.error) { currentTotal = sci.factorial(total); - display.displayValue(currentTotal); + display.update(currentTotal); total = currentTotal; }else{ Display.displayErr(); @@ -232,7 +232,7 @@ public static void main(String[] args) { break; case 23: if(!Display.error) { - display.displayValue(ScientificCalc.getMemoryDouble()); + display.update(ScientificCalc.getMemoryDouble()); }else{ Display.displayErr(); } @@ -283,7 +283,7 @@ public static void main(String[] args) { double principal = Console.getDoubleInput("Enter principal:"); double interest = Console.getDoubleInput("Enter interest:"); double yearInterest = sci.yearlyInterest(principal, interest); - display.displayValue(yearInterest); + display.update(yearInterest); }else{ Display.displayErr(); } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/DisplayTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/DisplayTest.java new file mode 100644 index 00000000..1c75791b --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/DisplayTest.java @@ -0,0 +1,44 @@ +package com.zipcodewilmington.scientific_calculator; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class DisplayTest { + + @Test + public void displayValue() { + } + + @Test + public void displayCurrentValue() { + } + + @Test + public void clearDisplay() { + } + + @Test + public void changeNumberDisplay() { + } + + @Test + public void testChangeNumberDisplay() { + } + + @Test + public void changeUnitDisplay() { + } + + @Test + public void testChangeUnitDisplay() { + } + + @Test + public void displayErr() { + } + + @Test + public void update() { + } +} \ No newline at end of file From a2cdeb9ad1ebc570eb6a06d25aaa1e75f6301cb1 Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 22:56:09 -0500 Subject: [PATCH 37/37] another ui update --- .../scientificcalculator/Console.java | 8 +- .../scientificcalculator/Display.java | 54 +++++++++---- .../scientificcalculator/MainApplication.java | 79 ++++++++++--------- .../scientific_calculator/ConsoleTest.java | 32 ++++++++ .../TestMainApplication.java | 28 ------- 5 files changed, 116 insertions(+), 85 deletions(-) create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/ConsoleTest.java delete mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index cf89ae24..970ba2b3 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -1,9 +1,5 @@ package com.zipcodewilmington.scientificcalculator; -import sun.applet.Main; - -import javax.swing.plaf.synth.SynthTextAreaUI; -import java.math.BigInteger; import java.util.Scanner; /** @@ -48,6 +44,7 @@ public static int getIntegerInput(String prompt) { public static Double getDoubleInput(String prompt) { double userInput; + Display dis = new Display(); scanner = new Scanner(System.in); println(prompt); @@ -55,10 +52,12 @@ public static Double getDoubleInput(String prompt) { try{ userInput = Double.parseDouble(nextNum); + dis.update(userInput); return userInput; }catch (Exception e) { return Console.getDoubleInput(prompt); } + } public static int getOperand(String prompt){ @@ -130,6 +129,7 @@ public static int getOperand(String prompt){ }else if(nextOperand.equalsIgnoreCase("off")){ return 100; }else{ + if(Display.error) System.out.println("Please clear before continuing!"); return getOperand(prompt); } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java index b46014d0..73a28812 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Display.java @@ -8,11 +8,6 @@ public class Display { public int displayMode = 0; public int unitMode = 0; - public void displayCurrentValue(double input) { - System.out.println(input); - - } - public void clearDisplay() { checkState = true; update(0); @@ -24,19 +19,19 @@ public void changeNumberDisplay() { int intTotal = (int) Math.round(MainApplication.total); switch (displayMode){ case 0: - System.out.println(intTotal); + update(intTotal); displayMode++; break; case 1: - System.out.println(ScientificCalc.Hexadecimal(intTotal)); + update(ScientificCalc.Hexadecimal(intTotal)); displayMode++; break; case 2: - System.out.println(ScientificCalc.Octal(intTotal)); + update(ScientificCalc.Octal(intTotal)); displayMode++; break; case 3: - System.out.println(ScientificCalc.Binary(intTotal)); + update(ScientificCalc.Binary(intTotal)); displayMode = 0; break; } @@ -46,15 +41,15 @@ public void changeNumberDisplay(String mode) { int intTotal = (int) Math.round(MainApplication.total); if(mode.equalsIgnoreCase("hexa")){ - update(Double.parseDouble(ScientificCalc.Hexadecimal(intTotal))); + update(ScientificCalc.Hexadecimal(intTotal)); }else if(mode.equalsIgnoreCase("binary")) { - update(Double.parseDouble(ScientificCalc.Binary(intTotal))); + update(ScientificCalc.Binary(intTotal)); }else if(mode.equalsIgnoreCase("octal")){ - update(Double.parseDouble(ScientificCalc.Octal(intTotal))); + update(ScientificCalc.Octal(intTotal)); }else if(mode.equalsIgnoreCase("deci")){ update(intTotal); }else{ - Display.displayErr(); + displayErr(); } } @@ -79,14 +74,14 @@ public void changeUnitDisplay(String unit){ }else if(unit.equalsIgnoreCase("deg")){ update(ScientificCalc.degree(MainApplication.total)); }else { - Display.displayErr(); + displayErr(); } } - public static void displayErr() { + public void displayErr() { //if math calculations don't work, display 'Err') error = true; - System.out.println("Err. Clear screen."); + update("Err. Clear screen."); } public void update(double update){ @@ -99,6 +94,33 @@ public void update(double update){ String dis = String.format("|%27s| ", update); + System.out.print("\033[H\033[2J"); + System.out.flush(); + System.out.println("-----------------------------"); + System.out.println(dis); + System.out.println("-----------------------------"); + for(int i = 0; i < calc.length; i++){ + for (int j = 0; j < calc.length; j++){ + System.out.print("|" + calc[i][j]); + } + System.out.print("|"); + System.out.println(); + System.out.println(" - --- ----- ---- ------ ---"); + } + } + + public void update(String update){ + String[][] calc = { {"C", " RD", "RD X ", " SIN", "invSin", "Off"}, + {"+", "X^2", " Sqrt", " COS", "invCos", " "}, + {"-", "X^N", " 1/x ", " TAN", "invTan", " "}, + {"*", " M+", "Prime", " Log", "invLog", " "}, + {"/", " MC", "Year%", " Ln ", " invLn", " "}, + {"!", "MRC", " +/- ", "Mode", "Mode X", " "}}; + + String dis = String.format("|%27s| ", update); + + System.out.print("\033[H\033[2J"); + System.out.flush(); System.out.println("-----------------------------"); System.out.println(dis); System.out.println("-----------------------------"); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 02d0cab6..bd8a4910 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -17,10 +17,9 @@ public static void main(String[] args) { ScientificCalc sci = new ScientificCalc(); boolean on = true; - Console.println("Welcome to Mav!"); - String name = Console.getStringInput("Please enter your name!"); - Console.println(name); + Console.println("Welcome to MAV!"); while (on){ + if(display.checkState){ display.update(0); input = Console.getDoubleInput("Please enter a number:"); @@ -42,7 +41,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 2: @@ -51,7 +50,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 3: @@ -60,16 +59,22 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 4: if(!Display.error) { - currentTotal = opp.divide(total, Console.getDoubleInput("Please enter a number:")); - display.update(currentTotal); - total = currentTotal; + double secondInput = Console.getDoubleInput("Please enter a number:"); + if(secondInput == 0){ + display.displayErr(); + break; + }else { + currentTotal = opp.divide(total, secondInput); + display.update(currentTotal); + total = currentTotal; + } }else{ - Display.displayErr(); + display.displayErr(); } break; case 5: @@ -78,7 +83,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 6: @@ -87,7 +92,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 7: @@ -96,7 +101,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 8: @@ -105,7 +110,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 9: @@ -114,7 +119,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 10: @@ -123,7 +128,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 11: @@ -132,7 +137,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 12: @@ -141,7 +146,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 13: @@ -150,7 +155,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 14: @@ -159,7 +164,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 15: @@ -168,7 +173,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 16: @@ -177,7 +182,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 17: @@ -186,7 +191,7 @@ public static void main(String[] args) { display.update( currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 18: @@ -195,7 +200,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 19: @@ -204,7 +209,7 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 20: @@ -213,35 +218,35 @@ public static void main(String[] args) { display.update(currentTotal); total = currentTotal; }else{ - Display.displayErr(); + display.displayErr(); } break; case 21: if(!Display.error) { ScientificCalc.memoryAddDouble(); }else{ - Display.displayErr(); + display.displayErr(); } break; case 22: if(!Display.error) { ScientificCalc.memoryReset(); }else{ - Display.displayErr(); + display.displayErr(); } break; case 23: if(!Display.error) { display.update(ScientificCalc.getMemoryDouble()); }else{ - Display.displayErr(); + display.displayErr(); } break; case 24: if(!Display.error) { display.changeNumberDisplay(); }else{ - Display.displayErr(); + display.displayErr(); } break; case 25: @@ -249,14 +254,14 @@ public static void main(String[] args) { String mode = Console.getStringInput("Enter mode: (Deci, Hexa, Binary, Octal"); display.changeNumberDisplay(mode); }else{ - Display.displayErr(); + display.displayErr(); } break; case 26: if(!Display.error) { display.changeUnitDisplay(); }else{ - Display.displayErr(); + display.displayErr(); } break; case 27: @@ -264,18 +269,18 @@ public static void main(String[] args) { String unit = Console.getStringInput("Enter mod: rad, deg"); display.changeUnitDisplay(unit); }else{ - Display.displayErr(); + display.displayErr(); } break; case 28: if(!Display.error) { if(sci.isPrime(total)){ - System.out.println("It's a prime!"); + display.update("It's a prime!"); }else { - System.out.println("It's not a prime!"); + display.update("It's not a prime!"); } }else{ - Display.displayErr(); + display.displayErr(); } break; case 29: @@ -285,7 +290,7 @@ public static void main(String[] args) { double yearInterest = sci.yearlyInterest(principal, interest); display.update(yearInterest); }else{ - Display.displayErr(); + display.displayErr(); } break; } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/ConsoleTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/ConsoleTest.java new file mode 100644 index 00000000..26956e70 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/ConsoleTest.java @@ -0,0 +1,32 @@ +package com.zipcodewilmington.scientific_calculator; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class ConsoleTest { + + @Test + public void print() { + } + + @Test + public void println() { + } + + @Test + public void getStringInput() { + } + + @Test + public void getIntegerInput() { + } + + @Test + public void getDoubleInput() { + } + + @Test + public void getOperand() { + } +} \ No newline at end of file diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java deleted file mode 100644 index cb7f0315..00000000 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ /dev/null @@ -1,28 +0,0 @@ -package com.zipcodewilmington.scientific_calculator; - -import com.zipcodewilmington.scientificcalculator.Console; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; - -/** - * Created by leon on 2/9/18. - */ - -public class TestMainApplication { - - /*@Test - public void nameTest(){ - String expected = "Hello there Von!"; - int notExpected = 1; - String actual = Console.getStringInput("Plea"); - assertEquals(expected, actual); - assertNotEquals(notExpected, actual); - }*/ - - @Test - public void numTest() { - - } -}