From 9321da63222b73ac939f068ea9e6ac6b3842279e Mon Sep 17 00:00:00 2001 From: vle Date: Fri, 7 Feb 2020 18:30:54 -0500 Subject: [PATCH 01/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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/39] 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() { - - } -} From 57b1684532c9af39e3bfee3630e9defb9cc0d0c1 Mon Sep 17 00:00:00 2001 From: vle Date: Sun, 9 Feb 2020 23:39:03 -0500 Subject: [PATCH 38/39] master push --- .DS_Store | Bin 6148 -> 6148 bytes src/.DS_Store | Bin 6148 -> 6148 bytes src/main/.DS_Store | Bin 6148 -> 6148 bytes src/main/java/.DS_Store | Bin 6148 -> 6148 bytes src/main/java/com/.DS_Store | Bin 6148 -> 6148 bytes src/main/java/com/zipcodewilmington/.DS_Store | Bin 0 -> 6148 bytes 6 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/.DS_Store diff --git a/.DS_Store b/.DS_Store index 3833d0c095466354fc23a0733bbda6748c967885..05feab9d4760ea10996b5188b42d95d9a83a7555 100644 GIT binary patch delta 138 zcmZoMXfc=|#>B)qu~2NI-d)DY+$`@Hk5B%^(%>#uU2UMFU~FPotD{hDZVqId7@O7B za&m~P8rpg$B!ku~2NI-d)DU0xV3ExtZQEo}B!PsX4Bwex)>^`}^0Um@@cB7-Q_Kq2WAp} z*_|CH@6y5eq_uHi@-j~I!O$kB{Q*KgzEAVM8F$Sn?-#aCd(h!#p$jXXMQ4 z&FTmW1HynXun-3P;iK0UvYIR+33`Dt9pi5Q0#ZWFC{=mnD9xI0~os@4rlwVo-4n^73Q9rQZq(X->3IoEx?+kG7 z2Wj#B|K{)gzYUT>7!U^jPX<)|Fgonw-Td7;_m+Iu2GCO|3&&Ls?^0mcs~E9-6~Ba9 Zfj?ja7<#N6!UK^X0ZW4n!oWfq_ytQ2ZQ=j` literal 0 HcmV?d00001 From f2851ff7750edcadfedf756fe39b68a88cde332c Mon Sep 17 00:00:00 2001 From: Moe Aydin Date: Mon, 10 Feb 2020 08:20:19 -0500 Subject: [PATCH 39/39] added UML image --- UML.png | Bin 0 -> 308818 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 UML.png diff --git a/UML.png b/UML.png new file mode 100644 index 0000000000000000000000000000000000000000..018e2886c705934c01719371e3187862fe6cbe76 GIT binary patch literal 308818 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

fH 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

^MD3#4=DMr`= z(tm9$4|9E>D#q^1R=4R7!4HdUO{i+R;J!-*rX|JpfarPGRW82)29F$7#z1;xOf?6= zRwJDKQ?2V_J}V5?7i!nkF0l62I7~xwHtky#U;gY`2IKTSniXl|UzW9giy<=iebw9m z>y!Tv)@R81UHd4gXlnHSYr12SDvn8mc|oX07!{&rCipwkX$IL z!i+au^8iD{cZI??B^Mt$HBXu^-ppp}7PTIekt&%^UDrXQPPbHmnce77zbK zUfCO4P*qQN`yhG{C+g&#iB;1RjJz#+zf1)rPn;@sa1x%VuwWDc~C= zfdg2_?4DameC@~4S5EhD!vU=GBNbgW8-k9PIkkDNCp*6JYWB!EJ(xFW?IPoha5~_! zVg@ub%Bj^G_CHqQMv+ApcOVjuE97pQ(uYKaY_BDExI*EZ>?a;q+`#7^mYIr;e#i~B0Anx-Yaj3subLbSo@m?$?SARqI+b_1Pd+u);>TC2Q1SQ) zmop$2`>g}&eEhdX$Z}z2geg`*GkAJ!1rk@Ti?g11E}2ne@YZJU*Q8zfq)VD5r9Rjb z)UC$p#!6hXH?gmkT{+S5N+bL6?eN=@iCu9Lfy99GL1_yrT<&DSAamyD2<3tI%va1a zQ9uZXC}|#Dr}3o68Ys0vf#Nzx0~D`Ei`f_t1q(Cc@f(5wNV81~3gQ&Tj%VX9(YIb* z2Vl=vMPLp9zYxYQ? ze03_fB=j;bFY!dRJImJWi zk5h1KHor)KZi)me2;Z|8v+AwpRE2S4tCeA)y_;|5%60X#;wO~RbA1F>C(+=avlV&| z@)OKKToUn(%HdV{(<8@J0Ci_0RXPLa5}F4` z;)#F(*L3DAn_C*6a?ycRtZ3~-(G^JAEJ!DK`I0!ff>ru7Zxh(Dxii6z4T$vmOJ^lQ zA&-k3Zr+f)u-sTDi8QQ&D*xX5Se=e4Bu8gHz6O1 ztoC2=kERg4y5;J70L|$5{V<_o~XL~{kY)=w+u8v)^ExiUeCG2w^6JNYwO+Jv$LcJtm zdug?9+rIXK!9J@PHo++OmrjwzSN)oMlJA=&uaV&v9yWPNlw2h0r`y)NDYZ1i${{lo z4J+8CdAHkl9lO8pUGgqB2a_289B0wl(Qy<0mdAiF07!|86nKo>-+vt;Qn_y&{=xPmO&S|KF-HdF>0{5ZX zLG4!vkRucidrKOda;(igt|DFlz&#cGJhtv5=qH;!`s6A|#8 zh$?70I#O1E~%ew_UBhw5pTp*O~t`|E#%to0V#;H_4%O(vqY=qCY! zpUbO1)#p=*?*BYo@kt^IY-+@K;TsT5VXv6^e82;zzs1M*55Na0K{!gBM4v^){yAT4 z!K`&YKYH!|0r=$mS~br4&t@$goJI{BNGk2(7@;$1;*QDZos&%?`R{sG8wjv{Tb6Ka z#O92{A#_SR6XC3R@-? zT~=@`8-k(gf&*2l0tO6SqY?f!jo6r?25-kT2U>MH(d^ssH7Cp}I2@vkBt43xunJCX zie8u{e)N7h_6+hOwTG-^oMm6uF+^LVa4ns-yw^jMN@At^cSBK)ytHU)G7c#f??^iMOs5zk zrrS+2=my58KS}2w86|ah1LYpn%tq&xS!)Gi$4Le^%r&?#4$`is9)dto~mUB&yfIwGG$m#w{0X?5KeTK?@G^XF_b zN_+tNtzh?gaPf@I(e`qVlyGGR-}-M)9ylY`hi!QACRf=wozAA4zVn)3tCnz=>Fn3H zS9DA6Jea^*%3y8#-HK3s-^_&zd{?n!neY~pPb|%duGfvzZeSJJ>21mlR0V!QDOS@p z`N#*~YZZL@blO&UaIEGd>_Qdhf!sqqy$o~7gikDfsRyr~y9#7QNQ$m&e2|lqBLWGq zRo34`mc=<1D%0hg`eV8}o!SaIq2s$Z)@{r6`i)Zn-ebSuq(7vw=&+~1J9kK-aaKW* z%vz_QJ*QQux22+cI(*X{XrsN{rZLs4>%+!tELn^<4tFL0kf>}J~K zwphbtV$d)=23tnkfeBQ=17r{ht+I4p_gsF)@x#-J#vqNCfvs|1nyajmop2YB&`NsG znMP{np~h^{8@Ye9tO@Q^xM2Kz|LeL^9{174vPZZP>=3>tJ@D}wFI9eckr#-XTjHzf zQmX=3fKgArvB2cpGQ?{CnL&LVzvt62E(dGS9yA=W9;OrDf#1K>W}aGG};_#-e0*{(SFvsy&n%FYHHx#n-6}uHX`9RV`ivhaa_F)3`hn>$R310Q@q^m7eegJoVvWeV! z;3WM<_s9{d|MWi`pO&^^D!x4%mBnPQJy4c)hrm$bN4gv2=w+^L+(B z0~d+WIYA~oOfp}~6f9!_{I(y+c@sPEB>Nbi!b?Lx-$xL5h3i7+z!rhCx`@}TEsvgf zYJOBn8r25juWf)!BiP%(w$n1ezm_5XBB>utJClSbmaNPK3FJ}I)d_33_GhyBwC2Tm zlp?0eOPGUWY-8L~pSop#0fOPGR&&X07jhhZH4XRfOksWcdiLz)Tky`WqsH$yu^&Bd z;O5g(Rr@E{8y;RaZzDIzq-j}GQ90T5bEwpbZ66Aa#85*cA^e5y{+U_=ocO*T_LA1{ z>*5-7e+pX^uwe4fym-Q0Npb;!Wk$X@+@G7Q;6h1taDP9FBd5iGOyo@|eGGDb>6hOM3n8j_;lz&Arkw@v+}>0O>v~32hmj-5i~y^&+;~+d7}oG(9`A>L>|D z6l&n$uK)9~|GVNB^b747cyEAV0$w)Kc8;5rKOL!vzX_Q4f)0*(mf)2>KvIHdNf1?) zFwf{N0Li`^D)3M-^CZX^J{)_m@d=P8U?Xq!1dBvs1*G^*x5a?_UPMT3KIr!hxa0}{ zS!1U_MVQ%RreUp{Sx5w%@ftA91m;cjts|XFVQHQyW{g8&g?6Uhn(;wd;H%~bTtQt= zpaE}v+^0tKVQI^Y#&E-{f=?FP%v8N!QzH{9QJn>)`SA6TTn}Ge*59SDSElYm1>V@4 zt6fsTC$e=)$UL@i39bCKnMUVG@rqd+Z;+rvP$5-!h+3L^${+tSV9>vuu)kjOkqRi& zzMBo#bv;Rtiq^0gGy$h)@|<1;`C~Ekrw8lf=mr^f=UJF!<(V{IAy30QfY;LM&$tWM zk6*2{>o`6m5%YyT?WIcNyEqZjZG`EaPvxD7yb-7iBDvMK{?TZxoYWbXVH??jY*m7Il&c z_Vb|HY>w3$$L0)1X{bvn`j}+I1t+EFEJL7Cd()QCsMRe&C;C1SH5)rEHs^gvtOM;e zt$LGeIrsv(V~l9(9DlO;yNB#@Vv_fy2WTP(ug&`Znudd>ZelUWccaVGjoLt!mF0ox zV!qWc+)Y6C8$dCT#WVdOmUCHQQee7h8Zk^VYK2fW=bI=EF&?#)Te(}jDU?->w9f#jFTh=Eb=S(+Mo2b7W)!3S=n^dve|*?lx#)|4bkhbi<`SQxsiYTz%M^XN6th~JLz=R@ zNc@POS&n%H&ISCYl=U_0{ibvMs1I1o%19Hgvo_aS#~mvUxySoYRhDT`24?Zo26vh! z+%&D(TiSmhaUVMWz}zk_tciR9AyWH3X|_h=U_+x@f?tBRjs+A~L2dT-E@V%yRvC zfR5?jMr19kt_ZP;2`icM2b|FAYs|c|;(ZVek>gVBv^YkOOWJU+U2pVuod5L6(B@Iq ziBh0?s--az$m8yqFqAkYdVXJK#QH}#vozT+mf#T*^Qn-rv@eAZH&2b)NE-HT-n(IC zT0Q*i@-(t=?jxqTqYTcB4Z4PSYs@A^Dbf31(MH30FRrfXLY2wpOL1|k4jWr7wSWkK zfMbZfkvVw&eIuRT=BdlgHE&R@-n|%|g2$3+31_)CEq4>g4);qA{B}0FyIl%Z;-#qW zmRQph^=`Io^`(DWPh#o$%^79K{J96yGPo3OTnefgQXcXR<{ko3`@c^20!D|08mCYz!!A;I&gR6*c^FQ#B zMI2-9p$^Wcj{qK(3P6p{Md9~;S!+-PzA?NT;cHkwM?gR{0}m=o3U z2>Rk6gezxz>1^+rg(h9RdX5)(>|US|7kC}$aw;A1@FB8ALWCrn_G4&?VtKFMy(Xmw zj^9|3=>HBY0(VYG&HmKG#1g-|i%$;f{HMNV?GH9pb9Q>x zE44l+J9LGP$2=GlzA{lE-8$UieSvCjs@!p}mF1@*r`&=Y4;rnICwr^Mbq4Kcy5sTf z3@u-s?7O_6RH-PAY9fR6<2=|pVHIr3|S z-jmkM-T-5~HOvwmVp6>Lb8j+^`S&jrUK+N+v7Fwe z#V6u_w0$StKwV2yeHE(}3}U|y+$vmVlv%d?C=7rFkzv<$gyzDxvQaMg#>Ag7qz<5c ztCluIsSY)hP@#6eX*bu&>TqXsJ_ZXS&l9Ab$xCNYH)>P4mB@5pN^qzP)57i7(lleG zCO1}ff?P;zFG-yc8LV&LKcysv-MfE(0M?LP`QEZu8TWuqRBgqx)ulYmv;|PdG4zin zaP5aPdcp8MTV5GUk2~X^%J14^E?IP^9phhMt80;{_H|#%b5XwpwQjPk97a``_cEl} z;3N){?h^q+w66NZCsXNpPTxutR7B%ZG1@5e@p9JCK9Z5vRJgt_Owz%l@cB5yEZsn> z*v{`k1NMrZpi1oV0AMX9_M-h-ZT2xsFP_(0nN2N$ETXpK%aTQ%{@OOJ>mlwtT#FA? zoS1-I_1qI6SH&BPIoDh3bd%^Du(t!bs>EB#9zbJz2MGqMehh)VwPxg~_n`Aiu^u-A z$Bd#+SXfi=*8#`418Hs5cflL(2-#ZyfYV)_zU2yK*GyE#`}9sRr{!~0adBJSthjjJ zojJ;eqw&84l57b;5?2NuNTN{9^@!@t`;s-MDX>evP)<_>9Pxx{qsDT)PYqSGp~S+S2BfHI8kT1={iKLuC$5m=%X0J;OxZ z6=?D@gkfe5BHllt6RXX82PLKbSCh%7-)FIo_T7@_4GQ5HKK# zri)4g+Pi_W|F8ahM0fs92^&a~rPxsNr`RAXFkJ&m1FcF5AY=mrntA!P;`?m-(bugQ zmeNK}y|q}8x2e}u8DO~b>`B*w&35Qvg2#d7P;X#B_8|@G|g|N`F2+v zZc|jvc-6}XdXH!Oy1YoE2i-Tn;mjPqU>a=>Snn=kJ`0Fvv2m*v zp*Rw9*Kcu>egMXA*adqcZwjH4TqnfbSGFsD-uSU|7(0H*9bZ;o2V|@UP_q(LZN|a* zkHWX!==p?6T|9LUyO=LEVmbZy&retz}Ot$cG}vZO+iqkSG_F+2NT;7dBWIj9e73)iPY268JU0JhtbAG&f?3XE?Rf(2_t&pc^sO$7^! zoSNlRrQ==}TemVe@Jb^#ok;_E>?q$WD2NBQvS8ZHWwUY*4sNDTYpZk7(zmiCWj4GE zcg+ApHo89@)c;6!xF;nFbb}=o#q})}oM9v+HpC)8Kkjih2(dcg9Q2gDwfY1*q?X(`06Gv>Gfx z54MbXhB_j3$5g<-JE?*r*_{AhEo^HtmU*MOu9*+Ci|NAWzx|XtGe_>GNzLBh+0|Gy*{tbe9 zjFXwD*`yfyi-LND(i%-C+Mf@bR!hz-Lmwdvj_BfJ0+pnr25j9b(RLQhEWU8O6|)R% z1N2ptDNZocJhqm+-B%#H9w;m@Gu0kHx_HyU#*O_we5o~91kqV!E`V^#r0`2YQPn1A zuW_iNCB|KHPSewKn1it#r2m;LtRYh1R4~JpP2fgsmw~kzt%Trmtd7ZC$z|gvBO_CA zmQYbkYxqgPo)pL*XkDQX&N`*-a*rJJ6ZghXLPiW~Se)?Q4TOqQ(loRedPh=m-%R^3 zp%88oLk&UNPH? zXD##w(#3*v&3@GJ0+d9=_VG-q^|YiWJZz;y+kJ%fMXxqms9m z@_^NHX~{#8(Q2urOHWv1B)z<9Rz}m+z3!9K}<;3sHk zWOR)L7Ok|8$kX3{ZP>5t?o@-m@H)BuA-E()|M98%e>$l+ya7%sFskRka2PbTelHPU z?{{9O6Tgy>nRVCReg~9rpuKfR*$x~+PBu4ztPY^-I$L>km%`agUZ%h9);b?fTuAxl zbRwPLPlBXeg7%WkA*9P23p8}C3WngbD6srI>KLO3Q~C#68w^^?Uqw?67S$pc5J*+zjAgCx+wuF|4sl zn$UT~v?cCDS4aOEM|WRfj_;m(`<8z7xp+o{j%}iaToz~?UnA$U&CX>7n**fFaYtc< zvO&2E4RA}FA1$E@iO;`A8)c6@p66V1zP21Yb3paWopg8V#xPyi;&6nur1n_n!#Kw5 zQ74)G>4aFwSkXS>$G;#?yTATt$dg*ZMcYYe1@hmJr`ER{`O^0}MozGa5O3<$SRAwU zw8$5s-2!+Mq!ILG9QU7M)ty*qo0O4__uoRxQ>`1p5Vyc&-1xbdxY!nG-Net@x-X`}sb=(Arj;jN{yG6DTof;E&pz z(O_Xq3cWZHDw4&Zvf(bhxgR{7|hLV^m)w@x~$#upyrl%>nl^=9Q}_VNb9 z)pSdNZHbTdx8u~f?0Vse2e2gUrRud`K$6TCIg73)vzPW^H3N$AgCH|cdhglW>L|$< zXEE)w6fJoCDXriS{^TH8nFNGeZUh+jZ~iF|QXFVanFa8t&%#fh{BHrM!fpcpq?|$& zcnmP0)21)w-u>2_+)=jryA}i>yc9Us1VB^AEE+T^UjgZ>G=z2ls_hfU9t@0+tXgCt zJ56PDex~>(7)w}!z)m*m&rQuMqYccEGbEho$JantlJ5p9i%8?byht4Km$zHh(iwEr zDZT=lsms%AcLp8Df{C3FMy%3Kq#e?GecSBa z72WJQ5(JJhxUYKOmjjle%v$Cl&s6Pj*Ja;h|6VfV=^2u$q5@z)38*3sVVm;?or{sZ zi{}wrKOi%@z1h5<7rCcL!{ja^!|b$?+R?_|!zE^O z10_XFl*e3GO_L*RW1f?(2Y5;ba8ZxztE-dlt{G#tw96hz=J6Xy25;b-Elvc#%UjjR zPEiA~IlY=7hYDC?uxX21kohqAHb77hBQbke zHBw}}pG<4kX{;#w-bU(>X&ZZZcRW@Tb{WeL3>N7x^YQhx<-c0*4!>&xV=);BlZUp! ztDLN~O^eM3A=`C<@^NsPN&g>HLbrnDq|{U%1LSo!RoTJ)gL3qFlvR;q*YK;0LjI!) zf)Sw7M46`2niNi2bGC>Dx+G)y(5A|56aCS?#_sy5IRVZO3s$U*B_{-;vA;fU3*~-l zuPj+FbvUDDUVuTei9F!AGA`sPcF%2FqG{*D z!p`ury^*^V+WpdV4#@0ed%e4`Pvu(r{FSEj~UHjhwN)ntsxTXINQRPmvr-~$}KAjjVOhIeS`BV-0ew!{$ zUN3mKsB2lgLkEgS2nvsCPf{p;&|rFbe>^PlWMaf=ezS--wGHpHja4ME&A1Q5%N3Axb_;IB zE>bA5;n|XuCZ?{ivBwy*)nCW5;+M)d3wrGeCPYP)s}rT{l&XD-^_?vx;usgtzq66d zW%Q65UCxe5IHB$ethvtLp5FjHb!0EeNE}7sS~{u*SpR);b3k1PxxWK-CB3`IoW)ij zsbrMkBiv@U--l63JRUNja9$@DF4I)_o{|gXr#5|V4ch2Qw^SJ`DH%qImRHLrmzi^< z18OP|Wi{GXE(c32VxJ9k`xsv;-##&T=7~H?1K)p14TfQ^3y#W$e|LNdUU3%9HZfQK zfKT!LyAJ}1s&I#<=#KhKvCb?zFVb7cN9`70jywr zjOLo$Y`b=?Wxf4cbhJ{a-BUX5MiEHBvlCGrjhD&2LWsN?F3R}bK@M>>@XB1iwb$T^ z`nDLPQ-bDja76zE)&iPZ8d`A~qv1OnyYH7^SBFee?9TXXJ>!N&-cgwYd#a+8oVqwwaa_T*Mi*~X0J6tQhX?70{`xUfp z7@1V&!)K@!CgXT%gMhwespeXo%EUp?_0Zq}35S_SADkAxQ$>~8h}!nQctiSm`}DY+ z(iyR(yQjayGc_`EG>FirTf{yz1IHxI7}w8ilRJ`U1dT}7P!sDCC04J;tDHR(ANug8 zV%A0LB5S%rRQFHzgZ9USTtoRY4&z~1;=|B^XKY)$Nu0bq(|9E$756wktJQu ztEC^EQnf>;9#_prU&?752Dq=1%84x9T!`3mpT@wXqEsx&=;-Dv9rlnDq}NE?XtqSf z310l3lCPhFD47d#5$E0Sy;Gw}^@88Du{i@U;J;WKm2~Sl9^k^Rv<4RgZ5ACluocz! zejrS3d(Yb0>yfeJ`z(r`j9_VVIHNAomaD6#5bg7(yy<-pV#X9bgFv2ZDiuhAQW6EFp0wNm3)IxQZvUPF2=j@$s-`BkJbZ~}NL;hp zCli$R1w;bODsQs(sPcL{F@@W_hL@AZ-JtlG31scz#^?kDf z_|68aAZdy2lUt86D2Dg{V!zBlfiNNp(J}Rg582w>G?rE63{NvPN#y8$gg!;9HW8xV zN0)#2sooB?G%fFibL`k^$vszE;FTG^AMiM@l~uJZBw30Yr^|h z#d8<6;5|_KYYH#PD>udb3~(3|FV5MkTCkC2Gw_sG35xS^Dg@_C=~nM>?X`gtqyWDp(~k<)0N@6=XijF0TXy~f?cwYU$h$NFL=R&R&V$9$SWMy*s;)N zZs=4iVmEI$p)EqMfxF8Bp|S!&b`+zUJVm4GcjQry0pT?M%y!!{v`cLiTpzt3pV(6) zn+LHrw`LJeZ%r**Qyjf&w3!Cd*u#Y_ctdEViw~;ewk~ zF9Ye6i#lNbrus}kJXB=YS-{ImRpx5~$p!}p{@%kMJn3~DZvtyt@{#l**!_cn0W5(C zBfK%juYse)eq;tdBZ@yR!BFKhP-BS?&6#O0e*#dFFAxAgb&P7M!R|etH}e7f{+j4d zj|(8|+Lm4YAK3zF_})5B1vx-#%5~P5ch$?ANFQZfkY zk-q-MFn5KIL>ZX+#2V+$?Gi{Z%&e#(tUHlbaCeLLM?RUo;>-&v>OrWcyE}Lu>T_l4 z%sIe`){2j?cx9-%N!Xvid5aJ=x2{q{W?S9hR(;lEj%jzusNNp3C=IXB=U|Ju(!$Ah zmWTFqK~3qbdiX*F(ra+?;DQbw#y+gp$CYVir>v@r=zU6XhcL&KJg446N!0LE5aot? z-D@UFAUU9pAy8lJ!AW@P>(akcU*ZJqV~#^uG4YwDOj~ux{n;zG@v$1`uSb2;!(eZK z1g;ldB;cK?`pcadB=E%1MzjI_Eo-g}0z8`HHATMbcwNS1DM3E}*Y=R~uSru2cp#Yx zQr<%?$+ARGf`dJNhU&Y$t@~sPzMO!%^r%)5=%Le1Oi6+;bPn(`(A9l_GgfjOx3FN{_AUTA-U! ztA6@LHq`voAn|r#oT;*Ly|qP8Zp@+YuZ|tg9(Kfwv#Uu?tjO=*g*vw*KeICL8dVm1 z@F5HlqipIrZVL08m+;*rptW{8FK9n$oybjpJ(Rirg)}^24?K&dUHf45{6WJP7JjhZtGFww-fW<74E}0R2 zzHWXkc`%KZq+N76x>y6}r#u<*(g9}Xy35w1yk9yixT0f_x>9AgGeifp>H{8RV{zqo z3Qo4jbb~CuT8n^?+%AX;NfsX7h>tp6g94G;HtoaD{^+mHQG(ayiojI9i8Q0nr}~Rz zR3xW^UK(@NWrEDF+m@BvXOCrL97b8dTetm}S}41&FoN|E0EhVYJO@4y>ir`U=G6#- zbk03a;_@6`0<@frNNQ3!+z-t7pV@?<5Q-~2hH3w z=4HWW79p?wWFK)evQvfBl`i_ zb{~n3^jViDJJ5Ifk1owd`Qqm7-XwsP|<6*y%hLyN*?w= zfnPk&X58U-rJ=>IkBxq9dbuOsd0;K1@@{jN85o5xSsiRY#(b!D`S}4bb24a=^}10z zt#~za%+J7t11e?5u|bcbM*_6q-4UvtL(1Nx?6a>mPb3I`xnI|b0^QeE5DanTE&{X< zw1inI#dimzhez@spVI`jBoJp1*pLWl#T|k+19&_E$b5fTMq-O_PY~ZSH8(2(m4sQa z07Cu`45)tU_a?~oFrov<3kjU6Dt^Dx!@V1~f$W4`nF^8kJb6;FzV8~m{I?P02ftqP zeP4@H-Psg{pH;umf-XD4$#3rY)S~hGi@+G<*^u+f7^L%XRqscDs3$}+7ICK3;VW>2 z1UX-h0t+?O>nuZHR8LNGc1O&1f04eHFH!)46|8+6EV!w79XtuRR>sneO1tdv!507? zsb3g6_Tn&%yWk0WteV+{%Ra$`Y-c2Xo4v|+ZMuD8IPi?{D;R40u()qBv!*@wAecse zCq|%#$b?D7wj&E$_W^$3<-*z8~NgP;fbuM_H9THwD=Ykm|*?BZ@v#(^y z9&>td*KxjwE|pVGngm}NDUI@as-#nZ(In$(zozn%=^ROvyJ_Wx^(%9I$GEN-Y`xLv z2=z)d2Io0#A_?}a?HMzImGqmWRXn3t{V$B(&EJgP&3`g_=YKPL-$@A8>{he&*5d;B zyrvaWJ9;?{F+9>eauECZKKXBztRw$PLWU20y#)H+pC|YZ0(KD4W7WM#O8xgPV+hW2 z{@7M<%03)zVJo7x9N@(^PQYclt^%()E4FS|ldc)p==@ZhbWy$wS3#3D3~=iMDb@^7 zJFA@ro_t@sfS>j&6zCtJ@CgyC0b*R1G%y6)mEPeIL_g=Z9e!C>OZ%ybM8YAYD$3uQ zvCc{SafK6Eq~;a6E(0vm$s%>&+8WRBu2{7dg6od_AQ8jks^gO3W$aA!^kf^wF!ruJ zSSxIIY7>d=i0@&q+LRcAcOMj^hsf@t_q%ejp=7>6XQ?U_MKPB_2cl$_f(8L*Z8&Bk z!mJGkI2=6*BNcRDJBBq~7YT!7DRP7m45lli z)DFPQ{eeT>!&b99-N{d~EqPVpGB4x_yQ5ODc@INLvDNshp!XvOMmFL1Zu!A+o@j~Q|MR%c%1?Rm zX?4_Or5)?i@;`P zo&f*H_u6?P;tv*cj)Z}*R~9Q#p80d4%GBcbN|6XJhQwzdGk(4na6Z{Juox0zELz)^ zDQYt*_a=BV6+(5~##Q5Xnv0BOYATb;$k5OuEHb`qeIM zQK6Nzk1~tHffLus=i|5Gx(_&>tFU$RZa9Ek)NSWfYkDO*H;1iDLso$lXwl5~^&SqT zOG!(`Fh%KImR4%EgVTA4TkJnxx)vaBq~?3wpE9yp!hpft?%HfyZDDpS(h((1v^1R3@W`F0w7&XL}yB z(P`4Pus&y$Yh8iQHj;N9DK?s^aa-WXGevvVjyTR7By{Z(;mXF&CXSPcKTB8&Sy?XS z>%t=*RnzgYPN_o!*mae~9vAiJQ>VNI zKJ+&KfUMzDb^MgRet(D;8FF48{LvSy^7qk44~`k3{p*#z)PRGhfB!W}CB!m!>6evbZhP}jhQd-hi7whaqEZ^?U~2(bI9(ux zwNi(ULd@=03HULw8O+t%92kOR6Fm%hyxY$xvzvrq$0RQI%S*;Rv$$JD>+JJ$eeTtu zO^x=OkD@jcL~sk!4xOS9^a3W#>wZilgfpYLIa3~;M6w%F4gYp4v1Iv1yyMB)Ga?~7 z2?;pfB|USV+WV;Faqy)g^N1)P4q5F{5p6Ox{a zDY{ji29ll!1ATXctYV+oOjbhDC_p0jecGQqH|&J@w_De{xf_$*nmYABaFH8hlqZJx z9fgo8GlD+pI&m2+N9D?c0^WHEEDaI(nAS`6OipeW~VmrS3E?XJiP42i?P;c)JHo z6o`YWdDHbLf0j~&uyN58-)O-d{j`+ycwijo`&VipANx-evU|w9bvcL*QxcI?0yAh; zd;_1UPUAV%E>A+R&sG`h^DC4*kQf7X^3jc_h@%qp9i#-W$_u~~N7kli*N?bmN_N7R zh{7}Jk0!w97l^tJoRk&Fr`SVbjR{N=wEY(^D!cd@SnSZR$vERUe2%kbv;=&w?vXVs6f}lS^K0Xxq-41~d{5e@^KwOB;`8x)}OVyCT zpxu6Qon#aY>prgnuin!SUJAYehVb6EARr?i{OFxj4_jo;fiKe}Ey4qu7dRX8FGuM_ zAPA)aZx{jYs{~_H@Od3Q#&aYqzXNPGKfF@xymv*WNmip?tZFQYI}dJTB-3>N_6yHS z14&D8$VF&-E{kZ`Rq4z3(p=@_XTNl7XO^U-?J|3szx2U&u9^mDkAZ=@V`2tP23#G? zbJlnYExVL4TgtU!tEyDMfp+tanAZ3f`yADkp^2U`jsct8vbXkWq- zfXcCEn=#Fg^Pq^sMG?xzkLnov5N0;xwGn45QhfN1w$$T-GH9g3LA=tO*ZvO-LDaBj-gJzsP1OGpOA4>iO_B@cz>wOc_-0C|HdQ7H1 zBFvO$@jpcq5Y~fxf5*AQdla#Ga|SlV2HIXq$QN;e-uS?qcbY=fNbJGY`C`@7?V zPz&(1(MzB(sou+XI=U1jwS$qYDx2Qnj%GU9yce`s77dzjE9_Kk_iWm3c%8kQ`t4Z{ z4`Thxl=i!d>XX`U8!$JfzJ{!kx#1X%5vmgXC@Xj(Os=ZRGjGPzV+Un+&q(;E=YcO; zCx#(Qvg!aQ@V)b|N^PviT7{e}F`xO&{t{JlccroA4};0=`-B{zcaXsotJ~8t84s=j z&s#hK@!>&gNY|UM<@{@9w;}vnjVgy^!fc&mP|)Lf67B3V+mSH6vu$5iDWp{7_EHo9XL24!8 zEbUD7#$R0A9IzDl^;MIf)P^Xz{F0S7RHjd~-uRK?%*PpqGH%{B%u81|@&ZU?Tg%b= zwouuw7o*Nw9Hq*-Fzj!nBHYo}lgwW78HJVk)axJZ#9A?>=}vxvY#?0=`smRmw$Zs4 z_J*kV(!rd!|A({h4y5|u|HmmpIYuSQQHYR~lyDA8p=4!clbx(=$84dDXh=8|W$(R} zz4zXGor8mO%;WrCN8@wv{eFMr`}?my8an6wdcU5}$K<(P@M2$XWi*BTa=s$lIBu!W z*IdyI0l#*{INA&E}v{#Ya9SbMa8q3KRUsgXdZU+}48aOVyBO#7)DhK|P~ z1n1UFyq=74;ARcVUn~u#s}9H-)m;mrlDTt-A}556eDv~OuFdWdbbWF*uj{B5_Jvl~ zmTJ5~OSt>B__=@&CFPpY#?im6WUwbsTP02T~c!h>$UXe#^f zsEN4RFXh$OCRvQfcJ212HSNlh7v@0vQ)TbA>jsF<7O@#Tx^V4rHQ9QGF6DP?1@OX` zBVWAPG_)z~vRIcExwb3rd5hy@>O;6e3Wf9H=;^J00R<1&L%;>q3ZC^G*6FRCJ$o~a zbinKoZF9^d=K}b20m!Z?T+}+fK}=hsxdk`A1FWDHxQ!p*+@;Lf8l}`(wGzN$kU8Y? zz9Io&oVX5*PQlyq;Z#+JX0c&a@#Q|8VPpb|gBe>@w|niXYmA*?;wy~DwPOmgrP)31YJ;f!l6NRy!VrEo0VbE)(SBX2ucNil98U1OvTT=Dxr z%D*x|s~cd*gs14ssqDT@E_NBdqa&Z$0;mWeS8RF*iupiVd)o&=Q76Q#S}#z8sQ#-U z>lR6n^+n{n@1n}Lld)s-e5lx-l-F}f(Z@m4XU}=^@NQ|RB5dZFKGnt)s@38^$LYv! zd0^=;kGxZ0FXphR0T61;Z^urxl$+d;K{I-^=$H!PMP~T^xnSk`23-q(i$LgX0*!i~HsmpyF#7Fy5 z6DT2Z9Hsz?uoUvD%bDI+HE?6LiZC3NM~x|vD2>;?vg@f%Z)*;(03<(U!~v^C~e7$rG)KGVz48k z+qV5k0%@@rEj~Z>DND09OG5zrV&4XCq9n-{((jH_X&rLQ?Ax%N?qX8jkIV?C*u>mB zyg0EP?&aTAFITj(7h?9acl)7zpFXOW20MIP%GqBp5T(Or)TJBzp0YMY%w-P~Ce1X7c|H_V1h#6BC&sxv}MX5O45 zQSgs1cdfXh>n~^(%*@D%zhj)K3Q^?=J{MCF>gEw-7`sGiu<4^Xx_WFdBh+yiuftih z#fmj=Zx1cZ7=f?`oTqDCimQsby@=AwzN9!(%#csmPtxHc02ATFj7IR zg$?~YOWkqYlc9KG|HS=iD+VHcrn{4tw?Vlhwe!8F9IHNBa{$+!hxa&rX@%O(P4wSY zRhfZsKk7tF67_A3et;&aqdI*A1CO06PYOccoN}wX#S?VaSjw9U*E|;CFiMn85{MF; z5&#~k(3FpW{dkfvmsD<$lBtHX6thwkz_B4)eK*!Ec} z;x0%3U4)Jxz@Q8=Nhp(L&k0C*XPZJ?KX=;tzsvyGQ)UA66is*4a7)0A=w9zcZt@X# zDIE~(1$4%G%4cEKpoKe_J6%8Ph{fgwSNA=WcoC}s)WrrEK|y#={ES^;8fXtk(miACysn*?Hye zxSFmW5W^If3)6yQ0uo@yBX++@7SCn(O8#*5>O)E`=R9pNFO0_w7U{u1RS;z0pL(jc zzG=?TVw*iDRWgt|R%Mc|yWuww_G z%s!9p!UMq8hQ>wx-TvcftsNYfB*i3Vuv-Nt~I29L2d6uY=Ia5 zlB%9;F~;TI1CAYQgO%c-t@WSs8F8gNPzw`2iRP`W)R5MgCh0Jlw^?J7b+@mxirc?V zBKnLoXw|vQceCZE$5m|K0S3e&WQe9 zM(GDh%PzPlmPy-7KgG@wOY-j#!bNSwL*jQy~=yXuFx&ETr_9QE)oA+Jw(SXv7NGmR}6Pjsn zSoaFSwq_n-)$rZv?7(Wz;k{#ny+4|%UCt%@2z%229WCKD{9q+V&oD;5{SLlCZC|zq1uik zbJp>Z2=V+lwt$py&rRbC5?y63E1%@J{Q`M%GeX_ad#m#8CX<_gyhi89z`UoGGa^BJ*$; zZMzcZwYwec_~Wp5Gf^jZU4?{d-Lj6pNkhn2LPQ7 zTR65G$L}gm-Kcf_T3rxo-;JF|NHw~NL%Y{+&(-xREZKYGN_|0A)ML2WuQHvu2q~PJ zN*n&fo0@krO^7{zG&T`uJ6cE=o*(IdNLwGFx7=c$BeKmnRTKr9$VT}ugFz3WW^ROZ4oz!pTIcVaT`|G1u=LEf_ zCe~g%UbSyL+Rd)2dMh4v9hSc@^9+0K*=u(xcF|A1&TiTwiLnmLQLep%-~;5?>)$Q& zn1BzrEni7o%A8B62wn=Ujq?P{_Rrqu;EBy3OcTFY*tGH*P9~p_O4tqYcubLAS6~ed z3{EG%SjdM&vNsMx#T{a9hdqGKr`-*ZQySn}k^t{$%Am+`$F(L&isk-%77$i@FV+)f zBf=0?8to@m(NnelV|LADhRSEnOuuWeRYxfKQ&WcbWgy#bl1LuWFTqU1GeDFFV(6f)7$}NhEi2A0C}zj zU^ZGxEIe`O;Pd{8qH+9ORetF!ps)R`_-;HPl~rwu#IO5OmK;xPO`~FW*-WO6!V*BYXDO}T!}xc!{akL>!Y?XZfzg<^)sKP!=;#lpk<()Bu=cjn)v%-r z7Q3z;^~x%ig~~p!H6nQrXfJ%zyEY1OUtLXTM=eu(`q0j{P|QX(QeF>uC)imR>7`em zI#o#Bx76!R)}Q0zZD`UX7aQ#7{@zs_DiO(vbSg8#=a*Z+Z#q92dbSe@??2N&fF}3a zkMaO7?t?;{?auu35J7|DBj^F-*-U4)2)|#XjxP38b_IQfNK8UGA5Iqzy?=M~NUFN{ z$^NEhbHXEUkh)panVr|%XWynEU5?SIp0ZhgbuH74^pYoGo3i^A8=KqfAg^0lm7X10i#y0-2J-y*f^c_PhVmSL-b5B_<2fxgFG_`9q4<(nTpOH_Rq$96q&~S=d!S{6eHtUTId#x2%KR>La z*yZA-lkCOZ8&wN$8RC4wAVRe~QgqBBCZWfw`s~P%TjIL-{yFS0%$S1#bARadPI07j zs$S9Y{Nb z1*zwhuzIP7znVkc6kUI>58xP)d>>KyuZnm+fsse?jIoN37sGv^BXDxRe5D$^_t_>P z=xk&$%%O4l;ONk_D>nb#8>D7POvwye$(oHD*z-R`Ipa=`JF4+-KhxW@!zFLJ)*aV! zLzA@%2}Z4#htXX8f+A1iUHb_Ke35pSz|C^QXP07mU>YF{^3^hz!=KHpJVv3slcSD)w$ITKC^B zCj%REirknfT+y*joa-d}&e1ckx@@RBD*)+cGVQ&V_AaQQGea|!24M|)2 zonPEqV|bHDGrZ6YzvD0n+1bjfy1?9be=9Iq;}{BtWg!Qj!dPp>P-!D45ANA6&-SUCrp?v7_K z-HcG-THgHT)Ky#blC@r&%gT9JQ;BMggKGiytQX+AyZi8=t(8Hwkev>OFt4TAWAO=} z{qOgsH=sJob{dN>70VpcB@XRYP>mLz+s3S`5m8uYSTdC`pPaTqfoI1gFE(86AOtn8o_$4aT*Bk9S?Lh6&QzgdjhB)$p;($vy@=fPh7 z;9)#a^6V_<0;DY(q+Q6nJ-i%n^aTqTv4AzQ?tLFKYSg_K9Jyf1!xju`(Z5e%Z8eAi zY;z!-7-0g@PyFYrFPn^yu7ERkD%k7x3vhvnt$aK7|Clsh(2)i=^NWy?cW-~2 zG^kxpnZwxtyZFUt1fqrrbQ1gll-i+!KovhjImJ^!QDOuH2o?J)-Vf7LI&!t-qZai$ z5){vL$bcc1i)4(EjZoN-r`>$_8d9i#^|d{mVAmp?2rDxWvl zYPg6zIS97kLKB}h_H&Jx^*W|Bpp0&XXm5Ap*f}STaI%trZ>u~fm#Ecs@?16O#Q}M& zeM+!4ie&R7umLwQx5^fQ>B@N12L(v>!Wc00D;I8!+a7vuZs5V9ZW+%KbR-UEWfGoi z9U1z**bSoG_XEYT(7&688gmZ0S-{}E6Y+M6)lFtd>pxu)+q+UkSmv1I2)bbp1n|_4 z#ao_HM#R~UU3%d;U+EP)s|j5N-j>kO-$seelO&^r$%J*mz?+j1uc3H1_ZzB5W~jRd%te#D&#YKWqr)97>p`dLG{4VsTniB0&+W3i*9$OoYZ5R5sYere76a$VBbI}-@$cR zCp=neK+PF**Y8*Y^743Ig}GC*;Fqzu!uU`Fpv#R@?cEJqUfJ5w(H9>`>m!SDUL0gA zoX!!Iie~-{0uLKO5ne`iKh{IxK-Au>UN{4|r$^OQ0`Va{6DkHb0Ofk+?s66IMU2Tg z^OLFg;DZc4azMV3%0eI7@9yyiRfSm|oQ5c9IZD;1mD~xRX7pYO^dTNPJl`XB-sgC% zfMfd+RT40@P#I|h2yP5EK%~|^bN_S14%|ju3p4(OWw+|h*Aa2pl zbe=mewIo$@yJ0jJak?RVE6sR@HmCU7BVpRruz`~6{6q?LZq6i&j`9Tqw2qKp))fM- zpaY4E74^Q(?3_E1gW7(!@=Nv31-oK&Kf*vS#5)nuD0#)112CD#+A++bUL)`qv`e&e z<&bL5CpD8w9Xhx@nu+urEAUhw=qq=*rIuEc{f=#(RFgS`doGQ;==7TYk-$vZH&{7% zvvRky%RGj95`1oRqH|YW@R&qeWYoxl970+h#BC8HSk9E{(xPzr@1VY%xc##W)2}BET+S9-*c&bcyB=< zYfjqdsjc4yvt#kuCa3lNd{F$19?W~>%PeSc=#s%@<}E4CfadvbC6naJ=Q6>T-DEieB1!EWRg@abTxyvvcRu>9yq#_xcVn=t@rTRlCI} zHXkL)ha4k>U(SG(lA0>unL!tUlBy?O6rLZza>nujgr0^&Gg5(;z_;?(+%s<0<#H|Q zEKoy>E8ata=d;%isH2@ZT~Z=I(qir`!(+)j!(XoL zf;!GdfdelNAF0N3AFBjPUG{GkIm!X118#VtL!_kc?vrSDi&}y88KY$oEc~w5TaTe- z3h_t$_u>$EPZK~qDC1?uU?GOj^-xa!xk52F(C#~Mq9=vfzzb5~6?>D@5Rc`oG_8Ht zs9F*wai#}Rz~WZN^t@D&a+#eZ2Uw9K!CwC^6FhEcrPE5?{mHQy?SG=B?zOq?vU`B5 zMLt)Et6ltU<>vica4X1g={?nv^)3Th9nKVL_H{`Qk+asD>V_T!jKSpoT#J4i?d)Dn zCu$V(>gTeE#VI>YZ5q3&K|#=J((c8ExX8d&L2_Rxe3R1nZ`~J+M^`u1pB-gaJPe$POn3xdm zCl7N=Rd}#C*GeqNcHO|9$uQj~=GtOce{OpD?}e&NX6-ekO8)4ra_G{p zvJADy>EmWN`rj!`hhQR2M@I0WigLE?nO8FJosg=u$6r{QPrhBp%wP0WAfZ(en3l8JYbpNFFVJFYmH%KBa5$;{u@k)n{< zF8lf>2AE^U5{cpQzEvUX3waetmabh+PjU|`L-pM2M_Um)bW#tZA6o6Mwa%U`yYt31 z))P7p*lLcl5G;L$acxq2;9QX|Zw8Wcsh7G+wxRUCE+=f73T%cjL}1Jwjbe(%hn6np z)?Kpv;FS)}$&Qh~o{kERbusG{G&!nV8r}nHL}F(!$QR0~EdfRdsVT zaVLwXmP{m-KvO90MElln)eKy4J)g+R_siieFp?MwU#+&K2Snap#;t#4R%anM>w$pG z4g3DuZqeB@Y}a`o0_`E&Ma~I5aS-iN$Ls*026|VLD604VuXJO9pC3PbsMI+gJ0-<; zK=SZVfNWn$_;ff=N$Nid?PnpE4iry=GipZH|3Y(>@}%FW@DRMq zMT%eZnB$T|zl{QktE|)AN?hWFhJs;Nx!@( zVWpxars^JPG9Wv~%&U6qIan9B<-T{n3j<(am;Nrb9S{Lm$}_h?zzL(2x${~Umo7Z9 z?xBCFGv?G)hKG(i@VL!yZxWm_gIRL6V_CGT)!4YoZ?v;y>V}}ViIPO7`lzT(hVIMp z@Ve}%<-gy(->9&^A7UtC(SGEU`Jla!4*WIrRNKTERXQ+o?R@!K7UKt9mi`z}`);%L z7}mA5-RqQ+F-BIsD#iWOPyr+FWz^2XFJ|ZeH2eVE8$B$@7t(&Sn&NmPsg_|6^2%hRG?C0=0r%9BeK?wA){Jh#fl>1v~JuloFmRiRbL zXr>c%wyL&k`^hqIyd=K*;duBP$-~J!IU`qZoWBeI5)*R?c}Z4-2|B;cUjF7OV)wQA zM&*}~D*g2t=E}egHYo(xM!0>dS)=X1*0D=TQV~T4aAT(xV*!yLu3RZ|n|>?%BA1e6 zSA2eO8W#B5LISTKUo%IPB`8H751H@bkJsyIM)l*p7706atgpI$^O~5>C1W0i8cV=y z`Yswh+4LFBk%s#*X$p3It>mq}N@$H1&-_qlZ?-Zo6ZDzG^W#Fo$z{{6CE~mtmnfFx zRN?io*hNppqxz@x1`!^oD>UndY zy8%`{mO3*l64C67fPw|}?_y)U86WX_MIO`(?xzfAjbE(obs&NEcq+|+%t0}l>=H1p z%!mc8f}vfI|5Ko;K zjlMS2?wYE-a*|;pjcVh}6cBgKl1H24C!@o8ku!rUQzm1!Pz&q2`ULKA;qo-};WKP{ z5a%B~DV5R@yS|HB;$W&bGJw0BJf$wcnusK09xXpCE+$6l+JH_Q8g?yAPDtw-tw+IQ zWdmU$?oPJToBMNpnIkYXEd6dkiohLN$#n{}nZT4U`yN(OpbsNc608^6{jJ2+r!LRp zFp@MK6<{v_NV6|VhrJJhGoF{jo>}QsfV=cm^#jWK3A|KQ#8#@z{nHIoO2r;kB(T<0 zdf{tU$d@7!<&y3zE}6LTkLC&ZA^}Oe{&$6@Z4wZl#n4n(UHLM3nUx=Uq_o3T&8p(~ z*xo?JgxV%uA0iU7&iVcOvbq5B>k?{8JA^GmujE;Li245LQ_I>&08U$RP+Zix-1jtE z#`VfLe)GpzxRd@3LV0RYc@9bU3I<?M?Vv*mIY0P8o;kK$ znq@%>k&9_RoX`{Z%@gU;2y1Zm?RZDEF>BlR1(hG-c!=BfZCSj7qUloF#jQmhA~PPm zsC}(8E&@GVtS$42bDll}#sdvqn~i#0Ja8DaBp7 zGc>wc77{=hPN@tvzJFwM>pJFbJZ1@DcmeJ8{2MG`Ev^>f=aB{rTeGTQJom7xz(zY{ zX^{mQw{_X6R_BHQAK#%?q6N2doybx@ctRtDvf=<+Q0sL8L#Wwm!h} zLF?h#=2fJV;1yKUfGpJVL;5PoPU9g9HK(Z1=SF&!@HO8*R|l>Q4nPiW&IsT9|NqW_ z|7<%`2awJAee&cxhn2scE98}e9%fgh5IStJE12jQ3B)I*FRTuxoC&eb=ikP_OU0C{ zpYHGYayIo~rV&f^CPTx2)9JoX0e9&*FiolL6C9BI>U8<=O?+n>j77^CQd;W1j<gO7qeQr5>}VMCIXiGr;zWqd|SsbHYH>rmyYZdIg0bDtv=&D8JHX&CtQnJclPg*lz@~gSW;8Dh_=N z+yl9Bhwx|w{lk*rVd6SaKuVa;e(>}%LBA^-=27reUo3KkC9W4~U>^31jR7I$-ou@N zvA3hyd4Xd$u6pN3ZfCkxvFgs9gR_jU$fF?pzvtu*$lz~J!q&f6P@V%b0jMOH_?HSw zun~iWR$Th8j-zBIgLJ7dNF8Lq?G6D&wD-^UOMlcF+cm`q($05Pwi#3u|7k1qeQHh; zM$JEsF)1bg^AKG=@NhubEy%T3degliQNfRUU=QyIZuw6VPcvk#eL{;yx=lodTpJmC z1j2-BkHx?wS^DEGql9B$U;YY<_oGA0?kt|5ohcUGA1CfHnro)}n=kR??3)zrgQe`q zt}o>=-<&ZbL>ciB;U?v>a1N;eJtagj<0v=>0>-K?l{(S(n~&4Sx*tv9!Ma_g3rNu% z-)WfA0-ZMs3Jm02qAH73HIr5I=3IwdbelBfKI7_$6m(~}VPksk8_)F8w4GvM%f|z# z_5#qxa@yN936-a&LajG_dJ#cGF3Z6l2qcuOwl|Hc)T@llb<}k>|2mQ@#m^qpE7^O7 zVPh4+2IveZ5MfYm_{jqP);LfWHw+#9@$Hp@N$J1XhBPQ}2fd2U@^7(;4600c>!}Iv z*$v))`<80sosqG9ntWLCd4E60mHp?T@t6xjNJE3dv#?hF@Qal=+PPK=l1I89ETEOi zp(>T9Uxiy~X8d&i#cUM9`tH|WN!GsB-`Ao)EuL@vs?2kpG8Ps!E4wKH3H_!SbF=an zwV_L*Ha5q+IQQ7v#Qc|}V@^?_`-}MPmi<;J)&=#+*62q8x^TYDz`)x8WfpP}@DPx+ zS^`Fwz1k?mA0MR@<+HcHMi)En?7tOSx1Jr0E?@qPF0!$|M_pdhlmj6=G4fpgwOWB+ zwn_=nhfz4*fA5jhlN0J;)GL-RaRVf))czbfzkXg*quhh~gR@3C7ypI#W&9T-EdPKS z;6jZ(bMUtmpGja&`STOe_k!#85^@XRw!J0EJRAPAP|k)S#22TwxjY`aFCL~?kKX;E zER836T-SbEhY<2F`$0Bgq3sg{R=2GwbTb}bTb<`G`{2hlY@oW5HnLo500YpPj@h#1 ziDp9L&g1>_ngz^wQ9@Pje0i} zme8KP(087Tto zNB$>%RBrT*)ml42m)6Z4j8e><%G?=muK$TSiERl4VDBRG5&E{_gGtud5hn3ikz>yr z9hHX4AtoVfC*DZj$#4=}yBzDI#|1gjdLUxZn~-L3JVpY*ezQh;@|fgjj8N3v_Q*IS32jQxMTGNLlA^yc(2p_EVTT}W!J)0x9f99`Re7y zCUov>7OACfKXqt+(NMU)oNFyrV4%Uhfjqt~?zl`BC9)J!`C9Bg630{Mw3Dtj9{gTG z|60x1ntRT_Tb54K++E@f^HqN2({_v~^X?zJlK1-CzY!EKI7qMaU0^5s$F5XKFs&?S zb|e9#m1#e9Du=Ho_=4<{@`__qBL{Er4^hAVr_&HEx|ReoJ(?uImYq8v2)dDhu1S;t z=rWV%b0(Fbpbq$VN3}_p2vXb}#DM)ddUkar7t`?HS@rK{IlvDF4L;Pbzke(1Nd8G6 zU=rg_X5I2Al2$Ur)z|y1rJO6092G=WAD(@4BO$WeM)gGaqLVO&{_5nKFGswAgxye* zg;Zw`#J#^hL3s=nJ<0ny+fq+z5!!dpYfFjvEFB2<$-K(Y>-TQfbWPQ)7pZhnb&P_M zyfwuc>V6+yf#lk_QzS{iYwCZ1I?l2a_xcir1kO``dS5u0qO+wl>XoB8y2lcxXvz-i z<98wuwAMoO&PP{^CdS?ZyOx5FM%$cS$cw2l^c(*pYVq{mLky`iRM2polTGVgVXV|n zt5D>icl{CFim({y@VorH<~>DbC(jkD7o3E*LjN}#lXdl%bZSETu33u?dCDD4D*YSb zRKUjCRv{(ZO`VUO@{2mPoQc>HXD1w#87-12|37=10xzkMZ0>`O;5%jIzfbD|PQk7S zg!HWf6WX?>SpN$I(Vb}vR3FV$RlgpcrR)2gn%y4-(JJUFsAH|d?xsdBBCN`3~{SbSxUeCb);+@H@ zGuZL^3;hEI^(YR-nFv_aQ8f+n9WWA8-wJ`X9&%qQQaG1{-oCLj!2I@$TT^c(NUDg; zrd{P@IRc^F8eX-13!XL}l4`|!y+vQFJ@ghDr|G;K6m#!(R8_=o#|QN$=8ps4z*i`m z9wQk}yEoZ2U^?qkocJtA^+ntjri56F_<*B%(<{BZ^J4jrd-&=#P4=Y%0^e6CC98#Q zSoNik@9gv#P=uH)L)?ocg+}V6fyqLN!4Cz1GIZ`z`(amtJ9%dN?cQWP{*(BcCT8Cz z=H?T-KSg5`uy?)-(fzpYHK^uQpLG8P^A7l$^vpr}py>g>15{F^;IKba(tile^+=^f z%v>++PI}sF4&1T>xkieOQWcr;WY#m`Cs_)c08&5+Y57`Ff%I-d4jlxTl|^6mZT7C1 zL!KS-l3e^s#&$+$@6ZtZ8>pzt2%*TeEmg-q024kEbeB_YZe=?CSuqbFq91Uv6GQpG z9Zu*2httWq|8O|*{1=DQf4G{?BHc^{!w@~fs`Br=hCinFL0+;_*sL|##x`OiXYMQq zOlkc=onmvfuW$Z0E|0i-g*QD_q*@>5b$3`6`Hu{?Q8V5a9K`B8z)zzG46dGpN@{FUymks3GUE3=i;UnY&EK zz;SMsE6wQ}Mlka}}I?|ypuj@P=>vcwav3ip)2w8&UUqeP9 zEb-TeK9`a&>~^`3fnlE&bQ=wi#9V?kK!w2*pl<;rbsPr2LY9p1a!td67*TWhQy>8J z*)wiIxoG*(RkjMDve?9&{Pb4Hi`qaE?EU>DsRE2v!BgrrB)?P&&kikcx39f?DdIaw z1VDJExZ?sP9Qd&8ss>L~2Gl~f4siI(r9IbSjTmv~o8`&s)zbaT5qp5JE*#yNz*kBV z_s4wQ6K&yxJPOgi@j3lv zJD1c7nz^=O1>>Di>4e8wq#U2OMqr!?NTpAld(~A9iir-iyzeF6IePY*$GWQZUSqJZ z8T*KPqMv@dREzL!&-;V7O0W73aXKr`PuYH|*1mF{mCI%u>4N#!dop7NwG=Z zX)A)Vc&v;~k^K}U+Sm_Dq3K<8#3ICX>bg){5>uV>=$PCUMfM}^uRXpJ$99XU9M@ji zwtEGE7`8Fii5l2MB8D?s+2HxBAYU{7Ie#7QPQ|rXd2;N+YQ0!gewd0rJKH{2BWBpB|7NtPgxnpTeS!zzus7z~?5Wr3iE^caKy(n4luC9TJ<2 z06r+$z1OK4Y2Dk2ZA{=GZ`@A&8*@EE)6P@i@kl`K&EGlh2$J$ME|P+7o}3M@I>CMf zjMMi6_I*j}^^Fk&f0{`?VUoC4Z?Lp5(s?tc{Oxx#0gu&FpAXmxJ=9elAPy#F;udeH zd?A^lqVoB^kP+OHn0|%nGD&-jDC!6U-XAxoYRSYa)t8)WtO+~Thx?>DQmhz9hN-6S z`peY|0<;3;%OG&@_`~x``A?*X2^*&$P25DpB}5_$HYWe88wxyU=6sNy?ESVj^PC)uHPPUEmhu6fB2h{kH z&$_=TGWgn%0E`w7oS?$I88g~>4A96drs;j27F0c8M`S*7M(hgnxA%emp?SpnO%0#? zFXon5C(LZN6IHOe4*^pm*LL|=AJIVev9Jwr1O@Gb0^Pc>M~uJ6#*!_Jl0xJ`amOd@$32OsiqTS?YcKaWbc@ct zqJwzY_>-}b4q7ufXz+}YWpWT5(HjxZa8Ec}wgYp^q(324?Qz}DUO7IVVD^`3OJW4? zwOIwM?r4b)+%WEI^;KM`qTX9#?f{c(pL4)b;m1+8^+iEsZ8|$Jb9R%=oLX-*5t-IjB5p31!3UCNf=j2K+8u22nQRB44x%y-tT%PGzC zEG;L3F%jHCy20iRH%blRb^z3gvm>cLP4(i=#o?ac-z7LSyOspWZM0}IYRy|R{YV57 z7n>qUPm$HxAgjvYXj23gz-z%r+Nm1bstT%vB0P_Rk3^b~c@H!XJ={I9I1pWYcuN_H zz08hS7VRGjoFje=vNA%xzVYIIjbFnUkwNkFrz5xB+=?#hZ3e{qpw;h%G0|?KHM& z!R@IsXUF!bFHHib8z35tSBb)Lm_A@$*;%0UpD?i(S0M@4OIMP2EiKo|f2f<8C3llB zi!0zhJYRk0umxwOs!wgkbBc|rwfF7NtIehDvLKckgnBgoK6vZk;3WeyqQzK$K5Z)K z7=0#3@M&#@0(auvfj!>E{8iUU1+dl;N7Q=NXxhQgBI@FV&=5+S76qBNPgbM;z5^}< zfi3=97UQVpzZj`%!D!q95o<$7zy($D^-kiZ&w3zYZgJ?F;l*yxzwt9AH2birs_xTA z0x@7_k7|Ks&dE%3!d*B+IRJWpwuO!=}E*XuX$P#h2Vb|xLLC*A5z z)v6B>(ous+>Vd#fp*S_vs9)F7am_GAw(?6eArm}#oYg~k54h?rtlJWK8bK2pM`DTw zO=#)P;JMH!PfD_oGtFeR1(vjqd?FwjS(iit-QK9-V|)W`E8jvy^@<=3y*EZzHW=Hj zccYf4@=MFS{~>znu5TE}VH5Km)B9c5&55tLa9f>%7!2&{m1|a++*UITa!wQBQ}73GdI(owU;07iW#l(XD&tHYW(t#@ON}%YdThO+jAR8j~gom zl7Ii~&m{{r{n?8{4b{W_gz#UZGD07r_X>mB<3g3XRj(?;+HH0TJwW|tTS8@ZFU(a< z5@>=uIa*vFAL2aDC*fKW94#~@psFTOzxT9b@496>XHkUiia?Z!{RGE$}g> zh%{uRRs7ime`!)r5R{$rDC``rM&5I0QzLXBlF)q@JFQ=Ki-Sq8CA?lmams40i}$G- z7_00IcK5Q7pnx?*%%*&w?gR53((a^oadD-x50r0ldU@hSu>M(Xbzi@7(2rZaxKx1d zfD}LZ4ySH64WCv2OI!f$s<{tv?G}O5LV!@5x_K~qDpHjgj$_`47u*Wci~U9>AXz(S zuyYO+kEM{2Minrf^GeYw!NYua8+?Z5K!WsAVn0zbOP?V7h6G@HN1a$!MN{w}p7*-F+(wQsiQXNcm)Sl3cJ_>JDxA6&i?yA70B28BDZ3W7t((Ok8^?w>0X>MB!-Q>qslFN9X!JLw)>Bh0z}9i za$e+vRoM(Zzg0tJdw3p6VBb5H{Llz4>$rkQb9q0Yn*L#c(|*Xz4J%QJZb46<+iRvB zlRk0a{Hoyt6>O?zQJ*80ibV?aSFXwp_JHaYF3~*OK&(Z82-0TB(*qOZo@r50V8htP zh8yp|D_lc~+`02oE}OO;OsjGw%x`3aKO(n6TW|F20DmeKa(DK2EKUF76^Hd%1z<}( zC<-F&{Y&#k*!dmzfw}YPYwwS~pad6_+>vD|gh-SbDfWP5XwPcpDqw&8P~Ovg02Bow zKL&frz;8w71gDKVJAJ&#OTO*4V|D<~y`;GOZTwa8&o%L;_~SyzM$M)`RSAt;>))6?hPkUqD* ztluWD;M>l3b@RS9?}Gd0eUTE!-GxG1g?qQlcq2{9DC4%;W9^xu6uq`(E7^vwLqyVa zsB_!8Fx+3?6|5`I709@|XBO@0ZU0~=GHtqT2gOhbMzujMZSRixxUU|!ms=M#0#vqr zlKkdq<&7N8o%Gz}{h-y-(qm+QWV#nJi1FCibg`I|_T~xXGBKasAKVdNy*?R{FqcJm zzBDtt@`xa=N`#RdUSjAZiG;ZloqW(>_K|m%^B+=~ggW>d0UnPU#w*oEcAAw@Q5s+j z`^>9fDY6rogUe}h0q#==I^C*z`;|8LfZ{MY$B;zSA1AvUJ-uoJ(s`D&*)l%G3y zx!QRA~XD@(3e!|vFPIZv!lhsR>kWy{4Bxnd72{PKA>&P)w!-m#Ri zv!oiJ>r>QUPz;I&lb{BuOjGjxSah-aWrfv_i8#Z8Yp|>(4M9J|)|CN=0c+$(FK!gw zqUh6|_pX)ZY-0X9Xg^XWF~Z><+>tv1k+;4s$Z0jG!EpI;U9WGn;g0t?B{;u^KsfU= zri4a6G6olul`_uSsefeUEa^X$Co3mAsD>CFYp(p<|pYxyIpV*WhsqS!)BxW24=?I@y> zWCcU@7CHY|@p6-b3N1~;%BW(a#anJHUx5`V!usoVC&!P6T2zS`aQ3x>Dj;{m4A=eh@-B3av=yoMxmM=bYI^EQK7&NC0XGmy$v z7bIL?-{>y#ORWMyHw<^eL_8qfxWeAJ1Ia)Fvta$0LQEThA8okqgWq&XB&eHkoiqLV zsAFH;jt$$~0z3;cnPSKUv#U&6r`Pu)s+Pw=>=00Z=!%Gho&F9EHd@7+e%4-5{s zavo-a^g}sJk2!s(@#CJbrP`d$J+}$mkgbVQL8OT7cyWSrZ>sv~ZDF;COgVG0UZQER zY(F}G^HxB{hK>#4&j5n(=_2qYo#M!PFAd~Aa?!YDZ}O7!8&vpZ$y146THd^VP2wm~ zZT#W>ew{BJ%tJ@Z9b62RrhFNJn+(0wN9!{eBx`Gx@GE}@w7+PXy2;+_R9$;Vm79jYqkUL}a$1i>nBKxEa4#dS|@6-my9smk5PlFl)V{&Xm37UHtZGPH4_}oF^?YwQtsG9 zP&k%BmFrHi%gQ@DO68~z`XK9hjJXwWdQT4JLSVwEncc3Mcbc5_j@M8bPD>3tn5CIF zZ!0PTWn&SsF;^I@Sw*a0?LN`2pmFWbT>){xqEC=qF~H8HH(H;1`nR16QT*G^6$L*z zBEvOk0gnZVQK7GGBAmRF1Lz$wpHt(IxDOSlzgl&J#zXx6im!-G{TMagEqTexcJ7O( z*Vt}*@9oYadjjk7E--CL1~O6s82odA`;nrUE1^$?vqSKji0Bgh+lmy}Lie%l&CeAX zy=l4}Gio_EHVuRQ*6W|iGLaGz!9K71pvSBpPWG2d+t~4WDHn(mi!oZjDY&- z0StAY#tr-qz)*$UT~0Z;uPlId8JE(faUKM^g?a!t{<^OBoy`{_H0}4O+xLC5E7+e| z%m9)qVEiYt0s{K#u3dg|?B6f0#Q38xKq%pG%0EQ$wQ2ky)7oL11EQEp{5ptMQBVsx zgWJLtjF226uWJ=xhs@Z*=%1q&1v2nAMnqa&KTglRse3k}s)0D}xKaxkVHNeA;N$Wi z{?qt{9o}Fc7yjkzT5=N47lI+o9je#0>KaI4@7tt(Puzt&+efVF4Db?HoTk`gtaP@c3UVmqDTIPZbG}WL3}YN%@-UY0GDhW*Lh^ ztV{zu_Bfj3qHb{7MASF@?^2$;Cokh?Xy+j8?1YP%`w+%ZInK^$R4DFtl}wPmXB}Rk zl9S3bdX{%GNN=kX%1H=1P8zL*%ePij2fDN++q>j0x$ALe$6F5t#;Z-Si~?I*|0rJP zuw+Rci5l%rm_iuVAL%bH*!+&;$i#yf7^~`2AOq$2NO@3KisriS;`UxkqiL8;Z%VO5 z-hl%QeVrq8Rx@M>7{2UdWP&0oQe+z4^D13$C2+}Km>)?JvVEJhWf+s-2lNeK(+_$P zhofT?J(&O`9290ChFLdHmxI?*;!XjBA0>#hzLPupxF^}_M5Xv0Av&JykRSR$*CB=5 za%LTiHuG{?5nu?9;?NZhim718-XpNBNh>x9A7QQf+l%819^4)HI>;GRy4?wMHq!fg zeNY-g%1aUjdxV?PtTk#OS=6=^`zpnw`8H*})aupojgl2mkgzI(5;%H~^h}>R394-B zFZgvymBki_1W{~w_w)LKWH2>tICpV0C^bbqXgF$A36OFYlY+KmN~+ID9K4c4b&J!9 z)C*Dt5IsEUMrpbTv^h8c$CaIAs=|=A`w@5$zX1%`Ic%GsCDi~P$WplfBtZR-U# ztt6G-nXRA)^?Sws|6=bwqnh5{Zc(a$g({*Vy{WXV2uMc(X$mU6D;AV0y@ZYkh=72A zN{bZfC6q);Kq(?1MS2ZV69^Dm5+Ibjg6{X6{}}h4Gwyir828Kh!X7&&zp~bP%AC(! z&ysP@vn|0-@(WsVnJHvxj{5ONpe%ua%hR9+ya$ z=i^Q%_&1C#wV%t^x-!OSqrw{%8+(g=MS)0R{U1BFqDn+EFuuZBUHkSg^O$bVevC$g z{{PsF)>;!!M=P_bUCv(%N9RK2UhWP!JOz<*d?2NNHJd7w_lF?w<%^7GHEHP7*|N0< z5~tghWMzppXgOIqVoi@+pSvuQ?ZBN@u|$(c!LY_ zr8VftOr@Vl5k6)So+NW*(=PYb`2NU+={)E#Xf75Ermz|nqwh5v zmEDBjr|%t|+#>%`9$=&z{6Il`zW3K6zp5sh_1YOq^Au+Ns`*n?RRl2_ z40Nh|DIOK*!VE3agoIn^(qPJ?5_o6|GgQU+IxM7Uo=LJaG3PhX*aqNOphYgJ#-3g7 z_k&CA^WQOr7}EPFozOWilf2w*l*R^mFl7yMf9jv0bH(xmCA}&ImDw!{N_lC@v5$#K zFW#s-kCh8A%?qb5Ba2MAd*Pa1MuU5>Jdd8H&!CAjyVvRnKOs!kX5A>)-^%skD2|U! zF2GZiH8+ZayZ1R2wgP{=*U8ye21%QsK*LLMbp1db4bs=)+S zzLO!Bg~6z_o>E%(4`*rniYYZ3%)}Di;EFRd zw13=|zISn6ca{7jUWyP8X4POlI-`yHGzzM%`D@!JkM8;J6+Ny~d9X|Kv_6fbV8dUf zk)N|&8g${6BXD{|k92VwM^9F|r;ZfLPe|DppSH5Lmhf80ODrq|eReDxA_fa<@{0w6 zDbi7;zuBR5dxle3ubv=jByHk`v_&re`+qwN8gqPhBZYW>XEm72NHSSrj|Z=Wo|NQ>{jNkwF z>n9}bG&DN;^;`xC{!9SwuFVFESvsRxe%){P-AhC=4~vD@i?|U3c6OGIX%uDda0s(dk64i_)l+8gbU zU!?!nl-Hzz0okbCRR0JJ&LmVLSkC~*Z}IP){Eu!!m^9O(|7#zryx{vGFKG3^j?1&> zIR4sX;TvF0NuPS^Lfv(OSI2TbT>BmAWfEOtWqLOMMo)%{{F_}O);YogPF=b-;5MvX|tFa_*Mm<*eG*CN@U> z+8at5Buio$IAxtA1{<=hL|_0JvVvn^m0>$>XWg(`HG{8CacWL%B*$O{>mTC#B7Oc` z8wxJH$nb$bm?GfZa~e$NgEf}Fjw9p^7(d|Ao<(H;^LIqKS;!;$NI*3&rA*eF=9y3^ z#mdULmt<$Q4LsON99zMCk+*DARldq`%OiIp2ejflHN5xd0J>t!=)FYM)z_K1-5rmXU;bSkFTrMD{~ z2c+V*BK6x?^^_dEe=%X*;#uLag&dN^6dyNioo9&(dQ|^XKjXTyb~$r!u)tS$!Rk`r z-#$_};lhevCYr0v+5deDiKBHdQW_M&5+n&8@9TW zMxQ0#zTY=?Roky{#&SaUyrr2zx9sY@{KadgFC3BG>WXk{;``WCZD~bc9HuRID7;h& z6|_HZ@5-UF?Q$rH7qhsoxt!KlV4F#jJiO?I6`qt@NMu4Kynyqpp3BYX5jVHtGYVKl z9CGJ(s7<2ehKY4IN=ZFI`@T?Yv)+ZGfW73zB|OS4$jhRVHMa49!y)TOk`+YjSo1B6&Ob%TSQ4&DPHOMT1-C*|Hd-|a;fG!_ zS77CL54~GzfA9GQ^c;fSsG2b2`b%O1$g5^BA>$J)OqBG7(jkUHcDDP0J4i{IXN@@t zx*Vp#rB)`#3#BcU{7!^|amoJ(7uh-~o8eCIm=Ha0nLFzfQ|8%7bbj9Yh;xg$KQgvG z8{#U(G(CqA$xO2Rh!|MU&~Voks&~#U9T~O@E}igNoiK~C+1|MZ+wt-_Xxx{qnNQO7 z)KFD~ZkEu!Xap3ic9>2L6|0Xs9u zenSyMk#5ek;q6&Wxn~$o8I()X4+j&>PUYbt(E_6Ls6OxD)Cbc>n?T%!f7gIWTNloV zzV|?jPn9&Qewn3g?AZj+b6R*Z=UvmUj1wXSHH2FY9dz@1QtepK8vHkl_S#Pl=& zt)TOXRLyD45z`hZ22t+KbvG+;$vGUwxyTcvSAca2S$Fm^$EOifPX z3#V+u{G0_YwBo$HRkrg5pACPi98uX@vYD~@YDPcDN0}i|AT3Yj@ek$4q!$TT7g$4{ z@X3>nvz!U*9Zz&yB+`_WYC`YVUmk*(zaBl-Fo8PZF!W~P(XZ5Ba)|qV(TxY;M8o`P zbv8yYlZF$Ik5SUU)cW_Wiy|pjQViV|Lyz}Lmn}-tvRhAz+Jk-yOA9_CG9~ewBHoTH zkm+S@nCC}0t3_XS=15ioD-6}Vb4OHYsj0RVWxz7+MJ&=Jgq*XxhLm`0`l2=6Q?PzB zeVcoL~SZK7lASyprlsk8bwmMaX`y4+~U{Mw&WPrjJ?$&TRC!|_(6^}HA7jW z5Ec4f<*{SHEeO(Jw*9Yqo}rXa@ED;U2Fu5v;Rf&d5JS3S+4CQCEDL)=49l3zf%gS? zAwc-U78w456K9h#m%%M=)}-)I zRi)5BBrm65AT`xQ-*nujDFh1BQU@2lzIyBZ{KwyW#FMsX#^fKZJBBxW@o;txZ^6mC z-F1win#4YNfRGUGG99N%qoHIuG=Z;`nPAOmE^51B2WgxD~nmT44gteR}_UGyA`b;?^gB&!=&?Vv;GIPnG zKT}5zqSe{7@@6rYpH&$|!6vAgIm+HNYsF#yf_y&SVX7f9jkrq5wRJG|#ow9Jw{Z@Q z*q_Q+)6{lZsdS3&UUM3)Eom7pu@HmrZC`;Fm?bFm{$itr}4HV;_HSw`6+^6|D575RC zs}`Pkf}GNG8U~ko_J^5&x+U*CQ)0FA%81qI-a+ojtziP2MRszjq7R{$l401n@8+z7 zLp_az%7sB}Prw0c9%e(D2z(POwd{{IY^h;na@dQN6_^!Z&ArmwAH#8~aZ~xylY`=( z7Kx8a;?4!tSa7VoZ02E9PEmgEdMv)kGc7-i^Ux8Mm6Ue)c!twfwq$TqcrL@6`NXnlUKJd+av) zZHdc)31f?C%{5H)l$W!%Q5VjWMk<85QN90S>xI zLuy`Khy^N|$^rn-ZjnnR!$v#fwePHg%pg*`&kTpA2CE8Dl1L`>o(uJz%-=9JYKEArm5Rmv9_Z9)6@qWRKaU6cqMg?&VX3X)&rQI;}Un zR8{iFTUk4hBg{~wIz8E5BlSRD0Djvna<_yQgDx|O>mHLnk)3db2@{X>`26@@{O8m; zMIjunXgF2%dO&)2`GtNPrTgOjl^orjZBwPD5ANM78SWo#y2qv&b$d{)_KpJHBM`Hm zCqy*pc83gZ2(dc%sw!F6;W3w{W3T`hmmA|CbNi13>s@fpuyKSV>v+4bI>Iw!AQ2U4 zG=m)&JeRb8Y*KJK>n6V3+WK?a&um}Jn!@~^UFPl6b>9aysgfcz8+OwC#Xw-j>*NIr zKCFwA%JclZ_^R4`s=3<$vG>0F@hNkhQ|hqp0WiEUz{5G~r)p;IWz0E9=?<6nol9tK zt!>jIS|jK88k9P`7pjY0Y3ahr{1}o9XP+uX>q#4K3r-JB^2$JJ0rA$J%gXm&9n?l0ljy*9U*7q-pDU zS`iw?&|CbH4Jjg|aIYm0*QSiGe_ZdA0dGs#sTB0bTFHM}E-alCvdq)tg3Y&iXe4-c zOFd4txYA}^G1}l8mg6wBco|j=M6Zx#%sto%bnswBwAaNn0LT{Kf)VTb- z-d<5)0YlGE?f1QoERR#!q-GdDE{)sA3o+0INN$yCopun))K>}A-;mXV^^Lw(2{fsH z*qR*qR0w43Eqo7p+P<$I&TLN|Y7Pv{X6$@w;qex|i#*)zWM!16tn2kH{l1&7O(2Te z=Vq$|!YYK-*6;!4ZnsF)mbrZFTuDdBqI}?h{~DKD;Zs+bY*gc#9R7up?0nLfMPx?z znOMlLCnEjxd`g%zT>6|ZX8*ZV;?Y58Ya;Q%+icP15W`;D#pc^>CyyHX+??e0ODzt2 zJsufxXaD!9C|N#lVz(1(#`dsE^vZ;WQW)-B_KIw0iN_cJUygEz+r&UIc>dkC=V!V; z@J&m1dMe(cO5wU+f_`Gwu36+Q#)Jt}d!<{;*IZ?@G66ShYU{)!2R7;|q8o6llO>{a zcl>6bD1?UtX6Y?CFLTd2SJZk3fIS&Dz|n1)Oc`^IoRsf>-PUUQ-t}-dNyR_R9?0>t0KAOt4j)-# zn5&}LU)uX{b9wy+Lj5hL3c|2SpYfdV5M$X-(WE&2liW}5+3x$PYFZke%eQC3B&t~nl~+caEw~@h6Ey>{W8z8 z_Mbi+xdhv%b2#Mj-*jR<*b=~hF+}#&1{4=(=M1U@A`KP&jMC zE^ym`0XJ2tTU=)az#OT^u4QG(gZ^QB1WPF|Oz2EtRaEf@r;A27BBvQdDat zN?0X%;?^}bt9iOJrSHtFAlH5$AX#Pf&oWqgU7t4Qmj8`nVlA0-2f)2X{$4HEw69gG zE{d`=X5aboTHKnSjI||0uyl+`7a_`enOC)&iY7bmSxt1@^`2BPpW*nKe#xtZ#B#ZQS{G~HJ9Ft#HG5j)@-N1GWWY-F`v z(~#$bb(;RxJm6m2$VuG8q?^nSfcl{J+RC#R z7ZmStVv;lyYGxobF&v|UUscg+I;C?yx;p8UY>AD)^db*ZTxQTuM>vJ67zI;=M#NnZ zDu7t4s1}!$`$W9HaJI6-z%?^Ejj15WXAh1*tzh+^=Hk5_^bD zt3`iuwY7jd3&8Ws?>e^bY@YXm$XJajd^WVZ{@Efp){{s0orr}?ncbZV-4}6REbQ)% zS$8$=Ac9z}QOz;UxP<%$>WIk63fJ@zJrge$PHgQ%?+Fn!1aGX*w|P7HM@Ms5T!5~! zjBAEw&_P$@_$62%mZRuG<1hr*qnOY&dwrB_$5w*GE1kZEniG~!ev?#wovU-0K#j^& zqQ)Cq@#lZ!PC^RuhQc@5QN{dCBKq7ZYr2gw6QUa*a7A=mA=Hq$Jvx^LR#z@CD*Tj< zJpk~^6q;zrmRR53z-=il{rn)s3gWS}{m|RBaBy&=ACo2{PjY^b3dyv1GN?Gozdp@2 zx6;iq_oJyO%2d9xc*Ir^&_AmDR6xAyqiW*!etW^ErbYNH;(1vQUS&^5i96AX4;#~n z`4TovJ(f|_UOJM5IapTY?!CpYBvVci08-!hTT6V{5~H1CR_97*Ff4L|`FVcDLl?yo z);>_zwVtUx+^L@E2tfHCj}5$Z53M|$^t-`J`Ib5e7F`oM-f@8>(*1re=kPDuE(b!l zx}C0o0O(V*`0bHhF@QGGl;(8i`_45XfWF|uD(EPJ zz&TD1oOJ=@mXY8Cq){d|{RVw;9+0I`>(CSEpKpB>-ar;2HrAVH@mhFry-sSsZ7X7@XZw&s zvfZ7#lzv~|KD-}yLw52qq1oHxdp^SmtC{aVj9g`X=Q5(f*=fVf2w8VArfE9v{p82L z8UjRM)=U_eH-5Kg#%niaq^$TwnW!V|kbJ4P9eK13;L7HRmfSUl)iACOXCWT z9qLrp&NO9I>ScpEkaijJkgN8wE--Z=Whg<6XXt7^l;RY6=F`VzwCksuD^(8Yv}>I< zkHMmZFK&0GcrgEXN(H2&46EfC0+Six|kK;Yzt7Nb!`% z{elj)EOr;MbThVhrm)t?2LRTX(k$Li@t9Ch`Go?y8fGTh5G(+?Z4bkE}7eLE?8g)@EbPP_C6>s zy?Z~;*MUK{)_AkP%<_VC=4R?Z;w~U{?)9|2{t4=CMN?#&E)IY}76+V$%&&6q!*8rE zhbA($M409zWayWG&5xZLXQ5{6edo93F^50*wgec;Op6a83HV^RQnIW<+)_XtLbpL+ z^_)1!UaTnB@G6ISFC7MoFUgGhb+o2%aUZV633>c#?eZo<7Nt~z$TzjfY#A{dKkc~YBO|;z8BOFJR_jgG402z z=zDkPH}zCigBzAVwP?~mX8401y)-z>>*p@b_5<6JuQ1v>P6a!*My7)WAgB4jC2h!; z)YZ)+Dz5}|>yR_XW^%@;wFAP|(#2`^4&>JV18khhGQT-juzERd$P02NB7CuUoV1-= zUCS|9@Y+43qErGLV(*Q6OIku15Wibt6mK)G_A5b;ovhL59!K?pB@fpBXN4)_<>hk* zEzZ^m9pJ9E3q~ZYLPLG*Ndf!K>i65vl}(aqka%22S=A1Y*6Cr zJqZh0r+04k5wDNq^CuCS#G4mp2}2T+D#F^GXYwEXg64dBNji1@GT{dw*YC8ei{cD% z+{8B{q0#c1?wz0UtfgoIW)(w-EH%r1)skvgVQqN#MZZ&Ro_=N^wa`)*gXHT;+|poS zO!s4+`LV^3D@B=pwX*hohJ8dXsMOOF4rg>mI<7F~LW#sz;}&~6hr235Do4iIQ-}Q6 zd8RAL-*Lfyic(hR%MG=8($Gs4o$WQs$?;#~4cLj3zpuqTDP8y$B%%8g}X5WA<3 z@=HySUkb)kaG9CkxDkii7c8`M!7JL2>L|rO4J1UhFu6k*OKp&rO$I9dBK*&iqa6&UR2e$bjGpv*$T6Vm*VJ;A7g zt=uMP(c2B_&4i&Ms>qJA*Rf7!rnga#Y2~yXV~3uwA5MBba9;VAsA18?iPz~xZ}+;p zdRv~?El$xZIcKQZ!3#qs-CNtm|dtP{N zO!nAzKU}=FVmwFII(gG;JC&}gA*JhMA?~@?0o~!O&D<;%qN%INOkQGR&Rr$mhtsb1 z_jmWp6WdG12;1%fCRBNGi|`*tmHHJ*_?}YPFtPubP;J|G2(nJ-AST6{Sz+z-cq_qm z_5r*i&Q&gGx;{PEd#*2p%6M6%$A4$k$Hwuq@M=gJkumTlzhcHgqBji!1=od2(yf=Ysx%; z5h{eP~?KA^FR>7%!ED#ruXu$pZpI-w2BS>)|$9 z38?*nFrTjvCPlw*TYrH{-HW?$uLs?ZYrM1=cR~3gJatnMr|=;1rSAE~lU@C>JsjQH zh{|z=F~vk7*ZEI1V1?>TiwP3~t$}XMj@k$-2=me{E!DO)0gNd+M#@z`RZ1mc3^bG)41#mV4iLqY6I3AW8yqjJo_zAj~gKf zf*u8xoCaVk^FB%yxqz~T&L$a21r3Vd#=Pm%5Ijz49zL#4r9kCT%&o3SQ^@lt>TQ|- z&rwgB8S28q3xmJ8VxB^ChUS@CD4CJrCBHNabdg1yxtu6hx77!+5@UL%8%g0LNCiww z^$V-;tzf;#NE%>n3bL z`$9aXLbXk_P6q>Z$V(In?OML=5tPC%#M5klNJ!rzA>C60^^x;5rw}VpsnV5$E~&}X zxKlsUTr((KKreh*hKKZXTmW#5%>`x(M9I^0_kL4^#^fOn=Se!(zYB~;@e{0P@V71I z36C293v(&U2rFa$ZoG1{etg`ef47>|WwDETMA6Z_%26EcaApb8aS6?Ue6e~v%4V8y zVen^TLqhvggx!M*(J9l0=G8Cy$^jL$WSqRMTfS(*V?euH7ct!|YaVr4Ta>b265o6uSnHx>QSsF(e#L~YWy`bH^o zKE9W@zyI32=3>0hAL6i&s%r4tOAJa)S{Rej3rBAP)j~k5pE9R}*k6GYJE(;f^v;g) z0$(ke9Zpg5kE7~I%H4|Y_?9+xs*+P%pnYFhGzHfijsm{7df>}C9F+3a)=&R1ao~K$ z0{Y%tH=W2_ob?R*vD^UXGG{o`aJvD1Dr;{Ib1nl@l;* z6-BFewpVRzlGhq06_J6{?7&<_s-rzyFrXhU=L&4S@G zAoS}?mn~m{muoTo%6FhVG6C*BU!j}w08P7I!$zBCqULE{146&&^A{! zf*Bhh#b*bB!9FlE($Jy76hierF#pg89{@=oX6GT(Zy+GaPTE69QLJRLUjmNqCs1T` zi{TtaPf^N`o4?%sdtqBL8QS$qYMS+jHl@6!`rNUQE!J`&NvBJz39n*uzq+%dTR?YV zljXE?nK=mlzd|G<9pIOM(D8g6S?D-80`!f#3yao0Mg~Qpp=}v{)~}t%io-|J72uKk zzq?Ed3w5-UIDsl?Jo_WNMM6^tIlglY#*3F(7*I|B zJWnuD1Y@#}dGS}~119}3nJNZi##bMsZEczJO&UYe7G*JKV5zdjXX@DJ(obesZz~%9S`~; z9UbVJSmw~#(czyfz(P|GmgwK|=h31Hxy&03SSBml$yolsB3a)Xz@U*`Z~mKNQ*Pa0 z6ex`^iogF?ealRL`ztCMWPopCPf!6D#7O^U?%$=Y%F6|w3@oExWk1;dtZj;rP%6%6 z(q|5F@w)^TPAXu;%)AM-f1{Tg%`%c6h-ANRetG{#znG)_ANs{>_+R~bg7wvVks}ph zkd}s5Nl7dfFjqMAlaz?!X#iZ*O+G+nh$Xf;~g7r&^ zbcV4Vt7B9iPe=l)Xktom9dI{CR!Mzim5!K*0m{EWh^BFb4z8X81j5TlEYRj@Er~zx z8FCvWS^PAZ+r8bmt8RaUid75$B~NgApT4j)!(#-k* zq<^7AMz4w23Llo36#pk7Hf&i0$xqgjRa4tTGm#3p2qoHKV(vW-68Xi&x&Wq{J!jW-R-%k*<>1v z82a8G0|%h{AE0>#;dv~SHn7WQ@^|vx;>nYb9_rrM}+NSUmV}WFSK@-HwDegGB-7ZLMT_moE4n59xa8^2f>IXzqMMC?8 zRZ!3&K4st9Ja;j0ZR$X~L-JpdVhkFbbSk*lPUjNUMQB#a9@wnWz>4M+O70V;sEvFv zB}>{t0gaq$T}ksHwI#2hIb+ zTaLVzHUq#c_}T21b;B7h2jbqd-{seC{rKSQhs&;!49}v@#Zyt$-1_=mG{FicJ~+h! z+(9WwI{7bvw3JcPE#$8Oh6W=!_*Csey#iB0D7fDMXEmNx8b@ku_ z-+!Qdd9j1afzjG{KNmSNSw1KQoSbAD}w2^5Y zX+VJV_04f@w;NoUCrZC$Yc(lMMdNO8iGuCj$-xYtHL9xum{zAm+5PtCr!-1TN4R^* zRpNIBrn;nG4ncl=_BEqt&gnw0Wena44kWZ4@GOO

8U5pW-+Ug0TJSFEz))3z=9ENn> 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 z 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