From 28cd444f5bee713b7c0447f49cc7e83ea3127723 Mon Sep 17 00:00:00 2001 From: Chris Allen Date: Fri, 26 Feb 2021 17:29:21 -0500 Subject: [PATCH 01/16] Created calculator class and added trig functions --- .../scientificcalculator/Calculator.java | 45 +++++++++++++++++++ .../scientificcalculator/MainApplication.java | 10 ++--- 2 files changed, 50 insertions(+), 5 deletions(-) create mode 100644 src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java new file mode 100644 index 00000000..eadc047e --- /dev/null +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -0,0 +1,45 @@ +package com.zipcodewilmington.scientificcalculator; + +public class Calculator { + public Calculator() { + } + + public double sine(int x){ + double ans = Math.sin(x); + return ans; + } + public double cosine(int x){ + double ans = Math.cos(x); + return ans; + } + public double tangent(int x){ + double ans = Math.tan(x); + return ans; + } + public double inverseSine(int x){ + double ans = Math.asin(x); + return ans; + } + public double inverseCosine(int x){ + double ans = Math.acos(x); + return ans; + } + public double inverseTangent(int x){ + double ans = Math.atan(x); + return ans; + } + public int factorial(int x){ + int ans = 0; + for(int i=1;i<=x;i++){ + ans*=i; + } + return ans; + } + + /* + public int switchUnitsMode(int x){ + + } + */ + +} diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 5f421325..2c1da6c9 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -6,12 +6,12 @@ public class MainApplication { public static void main(String[] args) { Console.println("Welcome to my calculator!"); - String s = Console.getStringInput("Enter a string"); - Integer i = Console.getIntegerInput("Enter an integer"); - Double d = Console.getDoubleInput("Enter a double."); + //String s = Console.getStringInput("Enter a string"); + Integer i = Console.getIntegerInput("Enter a number or value from memory"); + //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); + //Console.println("The user input %s as a d", d); } } From b6fcf25da9aad040ba418e2f1d0b5e2b27f5a5fb Mon Sep 17 00:00:00 2001 From: Chris Allen Date: Fri, 26 Feb 2021 19:07:00 -0500 Subject: [PATCH 02/16] Added toRadians() and to Degrees() methods --- .../zipcodewilmington/scientificcalculator/Calculator.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index eadc047e..544e2692 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -28,8 +28,10 @@ public double inverseTangent(int x){ double ans = Math.atan(x); return ans; } + + //THIS IS PROBLY WRONG public int factorial(int x){ - int ans = 0; + int ans = 1; for(int i=1;i<=x;i++){ ans*=i; } From b714bf5c5d5fd8e874f8c076c24cd93a2b0ffb0c Mon Sep 17 00:00:00 2001 From: Chris Allen Date: Fri, 26 Feb 2021 19:29:23 -0500 Subject: [PATCH 03/16] Updated UI --- .../scientificcalculator/Calculator.java | 48 ++++++++++++++++--- .../scientificcalculator/Console.java | 15 +++++- .../scientificcalculator/MainApplication.java | 13 ++++- 3 files changed, 65 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 544e2692..5d5149fb 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -8,28 +8,68 @@ public double sine(int x){ double ans = Math.sin(x); return ans; } + public double sine(double x){ + double ans = Math.sin(x); + return ans; + } public double cosine(int x){ double ans = Math.cos(x); return ans; } + public double cosine(double x){ + double ans = Math.cos(x); + return ans; + } public double tangent(int x){ double ans = Math.tan(x); return ans; } + public double tangent(double x){ + double ans = Math.tan(x); + return ans; + } public double inverseSine(int x){ double ans = Math.asin(x); return ans; } + public double inverseSine(double x){ + double ans = Math.asin(x); + return ans; + } public double inverseCosine(int x){ double ans = Math.acos(x); return ans; } + public double inverseCosine(double x){ + double ans = Math.acos(x); + return ans; + } public double inverseTangent(int x){ double ans = Math.atan(x); return ans; } + public double inverseTangent(double x){ + double ans = Math.atan(x); + return ans; + } + + public double toRadians(int x){ + double ans = Math.toRadians(x); + return ans; + } + public double toRadians(double x){ + double ans = Math.toRadians(x); + return ans; + } + public double toDegrees(int x){ + double ans = Math.toDegrees(x); + return ans; + } + public double toDegrees(double x){ + double ans = Math.toDegrees(x); + return ans; + } - //THIS IS PROBLY WRONG public int factorial(int x){ int ans = 1; for(int i=1;i<=x;i++){ @@ -38,10 +78,4 @@ public int factorial(int x){ return ans; } - /* - public int switchUnitsMode(int x){ - - } - */ - } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index 83f0e97f..a5f2b4ff 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -21,12 +21,23 @@ public static String getStringInput(String prompt) { String userInput = scanner.nextLine(); return userInput; } + public static String getStringInput() { + Scanner scanner = new Scanner(System.in); + String userInput = scanner.nextLine(); + return userInput; + } public static Integer getIntegerInput(String prompt) { - return null; + Scanner scanner = new Scanner(System.in); + println(prompt); + Integer userInput = scanner.nextInt(); + return userInput; } public static Double getDoubleInput(String prompt) { - return null; + Scanner scanner = new Scanner(System.in); + println(prompt); + Double userInput = scanner.nextDouble(); + return userInput; } } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 2c1da6c9..8d247655 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -7,11 +7,20 @@ public class MainApplication { public static void main(String[] args) { Console.println("Welcome to my calculator!"); //String s = Console.getStringInput("Enter a string"); - Integer i = Console.getIntegerInput("Enter a number or value from memory"); //Double d = Console.getDoubleInput("Enter a double."); + Integer i = Console.getIntegerInput("Please enter your first number or enter \"Memory\" for your stored value"); + + Console.println("Please enter the operation you would like to perform:"); + Console.println("Current Number: %s\n",i); + Console.println("Add Subtract Multiply Divide "); + Console.println("Square Square Root Exponential Inverse"); + Console.println("Sine Cosine Tangent "); + Console.println("Sine-1 Cosine-1 Tangent-1 "); + String j = Console.getStringInput(); //Console.println("The user input %s as a string", s); - Console.println("The user input %s as a integer", i); //Console.println("The user input %s as a d", d); + //Console.println("The user input %s as a integer", i); + } } From cb3fbe771b863f48be17b5b4ce55aa4347ac59e3 Mon Sep 17 00:00:00 2001 From: Chris Allen Date: Fri, 26 Feb 2021 20:11:34 -0500 Subject: [PATCH 04/16] Updated threshholdReached() and created test1() --- .../scientificcalculator/Calculator.java | 34 +++++++++---------- .../scientificcalculator/MainApplication.java | 11 +++--- 2 files changed, 24 insertions(+), 21 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 5d5149fb..05dc5aee 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -4,73 +4,73 @@ public class Calculator { public Calculator() { } - public double sine(int x){ + public static double sine(int x){ double ans = Math.sin(x); return ans; } - public double sine(double x){ + public static double sine(double x){ double ans = Math.sin(x); return ans; } - public double cosine(int x){ + public static double cosine(int x){ double ans = Math.cos(x); return ans; } - public double cosine(double x){ + public static double cosine(double x){ double ans = Math.cos(x); return ans; } - public double tangent(int x){ + public static double tangent(int x){ double ans = Math.tan(x); return ans; } - public double tangent(double x){ + public static double tangent(double x){ double ans = Math.tan(x); return ans; } - public double inverseSine(int x){ + public static double inverseSine(int x){ double ans = Math.asin(x); return ans; } - public double inverseSine(double x){ + public static double inverseSine(double x){ double ans = Math.asin(x); return ans; } - public double inverseCosine(int x){ + public static double inverseCosine(int x){ double ans = Math.acos(x); return ans; } - public double inverseCosine(double x){ + public static double inverseCosine(double x){ double ans = Math.acos(x); return ans; } - public double inverseTangent(int x){ + public static double inverseTangent(int x){ double ans = Math.atan(x); return ans; } - public double inverseTangent(double x){ + public static double inverseTangent(double x){ double ans = Math.atan(x); return ans; } - public double toRadians(int x){ + public static double toRadians(int x){ double ans = Math.toRadians(x); return ans; } - public double toRadians(double x){ + public static double toRadians(double x){ double ans = Math.toRadians(x); return ans; } - public double toDegrees(int x){ + public static double toDegrees(int x){ double ans = Math.toDegrees(x); return ans; } - public double toDegrees(double x){ + public static double toDegrees(double x){ double ans = Math.toDegrees(x); return ans; } - public int factorial(int x){ + public static int factorial(int x){ int ans = 1; for(int i=1;i<=x;i++){ ans*=i; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 8d247655..7cd404df 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -11,13 +11,16 @@ public static void main(String[] args) { Integer i = Console.getIntegerInput("Please enter your first number or enter \"Memory\" for your stored value"); Console.println("Please enter the operation you would like to perform:"); - Console.println("Current Number: %s\n",i); - Console.println("Add Subtract Multiply Divide "); - Console.println("Square Square Root Exponential Inverse"); - Console.println("Sine Cosine Tangent "); + Console.println("Current Number: %s\n",i); + Console.println("Add Subtract Multiply Divide "); + Console.println("Square Square Root Exponential Inverse "); + Console.println("Log Log-1 Ln Ln-1 "); + Console.println("Sine Cosine Tangent Factorial"); Console.println("Sine-1 Cosine-1 Tangent-1 "); String j = Console.getStringInput(); + + //Console.println("The user input %s as a string", s); //Console.println("The user input %s as a d", d); //Console.println("The user input %s as a integer", i); From d622b9e80f94dcf6edf5f069e0d5e52227a18c97 Mon Sep 17 00:00:00 2001 From: Chris Allen Date: Sat, 27 Feb 2021 05:22:21 -0500 Subject: [PATCH 05/16] Added draw screen method and modified Calc methods --- .../scientificcalculator/Calculator.java | 130 ++++++++++++------ .../scientificcalculator/Console.java | 5 - .../scientificcalculator/MainApplication.java | 22 ++- 3 files changed, 100 insertions(+), 57 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 05dc5aee..28d18009 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -4,78 +4,128 @@ public class Calculator { public Calculator() { } - public static double sine(int x){ - double ans = Math.sin(x); - return ans; + public void drawScreen(double d){ + Console.println(""); + Console.println("|------------------------------------------------|"); + Console.println("| Current Number: %s |",d); + Console.println("|------------------------------------------------|"); + Console.println("| Add Subtract Multiply Divide |"); + Console.println("| Square Square Root Exponential Inverse |"); + Console.println("| Log Log-1 Ln Ln-1 |"); + Console.println("| Sine Cosine Tangent Factorial |"); + Console.println("| Sine-1 Cosine-1 Tangent-1 |"); + Console.println("|------------------------------------------------|"); } - public static double sine(double x){ - double ans = Math.sin(x); - return ans; + + public double performOperation(String op, double num){ + double returnAns; + + if(op.equalsIgnoreCase("sine")){ + returnAns = this.sine(num); + } + else if(op.equalsIgnoreCase("cosine")){ + returnAns = this.cosine(num); + } + else if(op.equalsIgnoreCase("tangent")){ + returnAns = this.tangent(num); + } + else if(op.equalsIgnoreCase("sine-1")){ + returnAns = this.inverseSine(num); + } + else if(op.equalsIgnoreCase("cosine-1")){ + returnAns = this.inverseCosine(num); + } + else if(op.equalsIgnoreCase("tangent-1")){ + returnAns = this.inverseTangent(num); + } + else if(op.equalsIgnoreCase("factorial")){ + returnAns = this.factorial(num); + } + else if(op.equalsIgnoreCase("log")){ + returnAns = this.log(num); + } + /* + else if(op.equalsIgnoreCase("log-1")){ + returnAns = this.inverseLog(num); + } + */ + else if(op.equalsIgnoreCase("ln")){ + returnAns = this.naturalLog(num); + } + //below is placeholder + else { + returnAns = 69; + } + return returnAns; } - public static double cosine(int x){ - double ans = Math.cos(x); + + private double sine(double x){ + double ans = Math.sin(x); return ans; } - public static double cosine(double x){ + + private double cosine(double x){ double ans = Math.cos(x); return ans; } - public static double tangent(int x){ - double ans = Math.tan(x); - return ans; - } - public static double tangent(double x){ + + private double tangent(double x){ double ans = Math.tan(x); return ans; } - public static double inverseSine(int x){ - double ans = Math.asin(x); - return ans; - } - public static double inverseSine(double x){ + + private double inverseSine(double x){ double ans = Math.asin(x); return ans; } - public static double inverseCosine(int x){ - double ans = Math.acos(x); - return ans; - } - public static double inverseCosine(double x){ + + private double inverseCosine(double x){ double ans = Math.acos(x); return ans; } - public static double inverseTangent(int x){ + + private double inverseTangent(double x){ double ans = Math.atan(x); return ans; } - public static double inverseTangent(double x){ - double ans = Math.atan(x); + + private double toRadians(double x){ + double ans = Math.toRadians(x); return ans; } - public static double toRadians(int x){ - double ans = Math.toRadians(x); + private double toDegrees(double x){ + double ans = Math.toDegrees(x); return ans; } - public static double toRadians(double x){ - double ans = Math.toRadians(x); + + private double factorial(double x){ + double ans = 1; + for(int i=1;i<=x;i++){ + ans *= i; + } return ans; } - public static double toDegrees(int x){ - double ans = Math.toDegrees(x); + + private double log(double x){ + double ans = Math.log10(x); return ans; } - public static double toDegrees(double x){ - double ans = Math.toDegrees(x); + + /* Figure out inverse log function + private double inverseLog(double x){ + double ans = Math.log(x); return ans; } + */ - public static int factorial(int x){ - int ans = 1; - for(int i=1;i<=x;i++){ - ans*=i; - } + private double naturalLog(double x){ + double ans = Math.log(x); return ans; } + private String err(){ + return "Err"; + } + } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java index a5f2b4ff..548dc1af 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Console.java @@ -21,11 +21,6 @@ public static String getStringInput(String prompt) { String userInput = scanner.nextLine(); return userInput; } - public static String getStringInput() { - Scanner scanner = new Scanner(System.in); - String userInput = scanner.nextLine(); - return userInput; - } public static Integer getIntegerInput(String prompt) { Scanner scanner = new Scanner(System.in); diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 7cd404df..4c0a33d1 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -6,18 +6,16 @@ public class MainApplication { public static void main(String[] args) { Console.println("Welcome to my calculator!"); - //String s = Console.getStringInput("Enter a string"); - //Double d = Console.getDoubleInput("Enter a double."); - Integer i = Console.getIntegerInput("Please enter your first number or enter \"Memory\" for your stored value"); - - Console.println("Please enter the operation you would like to perform:"); - Console.println("Current Number: %s\n",i); - Console.println("Add Subtract Multiply Divide "); - Console.println("Square Square Root Exponential Inverse "); - Console.println("Log Log-1 Ln Ln-1 "); - Console.println("Sine Cosine Tangent Factorial"); - Console.println("Sine-1 Cosine-1 Tangent-1 "); - String j = Console.getStringInput(); + + Double firstNum = Console.getDoubleInput("Please enter your first number or enter \"Memory\" for your stored value"); + + Calculator myCalc = new Calculator(); + myCalc.drawScreen(firstNum); + + String op = Console.getStringInput("Please enter the operation you would like to perform:"); + double ans = myCalc.performOperation(op,firstNum); + myCalc.drawScreen(ans); + From aaf1a04b4a7c396b754788db36cc69579cf387d5 Mon Sep 17 00:00:00 2001 From: Chris Allen Date: Sat, 27 Feb 2021 05:38:15 -0500 Subject: [PATCH 06/16] Made more changes --- .../scientificcalculator/Calculator.java | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 28d18009..289e0866 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -44,14 +44,15 @@ else if(op.equalsIgnoreCase("factorial")){ else if(op.equalsIgnoreCase("log")){ returnAns = this.log(num); } - /* else if(op.equalsIgnoreCase("log-1")){ returnAns = this.inverseLog(num); } - */ else if(op.equalsIgnoreCase("ln")){ returnAns = this.naturalLog(num); } + else if(op.equalsIgnoreCase("ln-1")){ + returnAns = this.inverseNaturalLog(num); + } //below is placeholder else { returnAns = 69; @@ -112,18 +113,21 @@ private double log(double x){ return ans; } - /* Figure out inverse log function private double inverseLog(double x){ - double ans = Math.log(x); + double ans = Math.pow(10,x); return ans; } - */ private double naturalLog(double x){ double ans = Math.log(x); return ans; } + private double inverseNaturalLog(double x){ + double ans = Math.exp(x); + return ans; + } + private String err(){ return "Err"; } From 6f5c663c9973a9163c8f22420cc6cbad1ee2a143 Mon Sep 17 00:00:00 2001 From: hazel Date: Sat, 27 Feb 2021 16:04:30 -0500 Subject: [PATCH 07/16] Implemented continuous loop --- .../scientificcalculator/Calculator.java | 90 ++++++++++++++++++- .../scientificcalculator/MainApplication.java | 27 ++++-- 2 files changed, 109 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 289e0866..c8c319f5 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -7,20 +7,58 @@ public Calculator() { public void drawScreen(double d){ Console.println(""); Console.println("|------------------------------------------------|"); - Console.println("| Current Number: %s |",d); + Console.println("|Clear Memory |"); + Console.println("|------------------------------------------------|"); + Console.println("| Current Number: %s |",d); Console.println("|------------------------------------------------|"); Console.println("| Add Subtract Multiply Divide |"); Console.println("| Square Square Root Exponential Inverse |"); Console.println("| Log Log-1 Ln Ln-1 |"); Console.println("| Sine Cosine Tangent Factorial |"); - Console.println("| Sine-1 Cosine-1 Tangent-1 |"); + Console.println("| Sine-1 Cosine-1 Tangent-1 Invert |"); Console.println("|------------------------------------------------|"); } + public double performOperation(String op, double num1, double num2){ + double returnAns; + + if(op.equalsIgnoreCase("add")){ + returnAns = this.addition(num1,num2); + } + else if(op.equalsIgnoreCase("subtract")){ + returnAns = this.subtraction(num1,num2); + } + else if(op.equalsIgnoreCase("multiply")){ + returnAns = this.multiply(num1, num2); + } + else if(op.equalsIgnoreCase("divide")){ + returnAns = this.divide(num1, num2); + } + else if(op.equalsIgnoreCase("exponential")){ + returnAns = this.exponential(num1, num2); + } + //below is placeholder + else { + returnAns = 69; + } + return returnAns; + } public double performOperation(String op, double num){ double returnAns; - if(op.equalsIgnoreCase("sine")){ + if(op.equalsIgnoreCase("square")){ + returnAns = this.square(num); + } + else if(op.equalsIgnoreCase("square root")){ + returnAns = this.squareRoot(num); + } + else if(op.equalsIgnoreCase("inverse")){ + returnAns = this.inverse(num); + } + else if(op.equalsIgnoreCase("invert")){ + returnAns = this.invert(num); + } + else if(op.equalsIgnoreCase("sine")){ returnAns = this.sine(num); } else if(op.equalsIgnoreCase("cosine")){ @@ -60,6 +98,52 @@ else if(op.equalsIgnoreCase("ln-1")){ return returnAns; } + //two variable operations + private double addition(double x,double y){ + double ans = x + y; + return ans; + } + + private double subtraction(double x,double y){ + double ans = x - y; + return ans; + } + + private double multiply(double x,double y){ + double ans = x * y; + return ans; + } + + //NEED TO FIX DIVIDE BY ZERO + private double divide(double x,double y){ + double ans = x / y; + return ans; + } + + private double exponential(double x,double y){ + double ans = Math.pow(x,y); + return ans; + } + + //one variable operations + private double square(double x){ + double ans = Math.pow(x,2); + return ans; + } + private double squareRoot(double x){ + double ans = Math.sqrt(x); + return ans; + } + + private double inverse(double x){ + double ans = (1 / x); + return ans; + } + private double invert(double x){ + double ans = (x * -1); + return ans; + } + private double sine(double x){ double ans = Math.sin(x); return ans; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 4c0a33d1..0f8c1871 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -5,16 +5,33 @@ */ public class MainApplication { public static void main(String[] args) { + double y; + double ans; + Console.println("Welcome to my calculator!"); - Double firstNum = Console.getDoubleInput("Please enter your first number or enter \"Memory\" for your stored value"); + y = Console.getDoubleInput("Please enter your first number or enter \"Memory\" for your stored value"); Calculator myCalc = new Calculator(); - myCalc.drawScreen(firstNum); - String op = Console.getStringInput("Please enter the operation you would like to perform:"); - double ans = myCalc.performOperation(op,firstNum); - myCalc.drawScreen(ans); + myCalc.drawScreen(y); + + while(true) { + + String op = Console.getStringInput("Please enter the operation you would like to perform:"); + if (op.equalsIgnoreCase("clear")) { + ans = 0; + } else if (op.equalsIgnoreCase("add") || op.equalsIgnoreCase("subtract") || op.equalsIgnoreCase("multiply") || op.equalsIgnoreCase("divide") || op.equalsIgnoreCase("exponential")) { + double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value"); + ans = myCalc.performOperation(op, y, secondNum); + } else { + ans = myCalc.performOperation(op, y); + } + + myCalc.drawScreen(ans); + y = ans; + + } From e6378a29f659f2177fc4e4931ffedf4f53a7a388 Mon Sep 17 00:00:00 2001 From: hazel Date: Sat, 27 Feb 2021 16:43:45 -0500 Subject: [PATCH 08/16] Began test classes --- pom.xml | 14 +++++ .../scientificcalculator/Calculator.java | 46 ++++++++------- .../TestMainApplication.java | 59 +++++++++++++++++++ .../TestMainApplicationTest.java | 14 +++++ 4 files changed, 111 insertions(+), 22 deletions(-) create mode 100644 src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplicationTest.java diff --git a/pom.xml b/pom.xml index e7cb4f6b..ece71c64 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,20 @@ com.zipcodewilmington scientific_calculator 1.0-SNAPSHOT + + + junit + junit + 4.12 + test + + + org.junit.jupiter + junit-jupiter + RELEASE + test + + \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index c8c319f5..d22cfe8b 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -99,92 +99,94 @@ else if(op.equalsIgnoreCase("ln-1")){ } //two variable operations - private double addition(double x,double y){ + public double addition(double x,double y){ double ans = x + y; return ans; } - private double subtraction(double x,double y){ + public double subtraction(double x,double y){ double ans = x - y; return ans; } - private double multiply(double x,double y){ + public double multiply(double x,double y){ double ans = x * y; return ans; } //NEED TO FIX DIVIDE BY ZERO - private double divide(double x,double y){ + public double divide(double x,double y){ double ans = x / y; return ans; } - private double exponential(double x,double y){ + public double exponential(double x,double y){ double ans = Math.pow(x,y); return ans; } //one variable operations - private double square(double x){ + public double square(double x){ double ans = Math.pow(x,2); return ans; } - private double squareRoot(double x){ + + public double squareRoot(double x){ double ans = Math.sqrt(x); return ans; } - private double inverse(double x){ + public double inverse(double x){ double ans = (1 / x); return ans; } - private double invert(double x){ + + public double invert(double x){ double ans = (x * -1); return ans; } - private double sine(double x){ + public double sine(double x){ double ans = Math.sin(x); return ans; } - private double cosine(double x){ + public double cosine(double x){ double ans = Math.cos(x); return ans; } - private double tangent(double x){ + public double tangent(double x){ double ans = Math.tan(x); return ans; } - private double inverseSine(double x){ + public double inverseSine(double x){ double ans = Math.asin(x); return ans; } - private double inverseCosine(double x){ + public double inverseCosine(double x){ double ans = Math.acos(x); return ans; } - private double inverseTangent(double x){ + public double inverseTangent(double x){ double ans = Math.atan(x); return ans; } - private double toRadians(double x){ + public double toRadians(double x){ double ans = Math.toRadians(x); return ans; } - private double toDegrees(double x){ + public double toDegrees(double x){ double ans = Math.toDegrees(x); return ans; } - private double factorial(double x){ + public double factorial(double x){ double ans = 1; for(int i=1;i<=x;i++){ ans *= i; @@ -192,22 +194,22 @@ private double factorial(double x){ return ans; } - private double log(double x){ + public double log(double x){ double ans = Math.log10(x); return ans; } - private double inverseLog(double x){ + public double inverseLog(double x){ double ans = Math.pow(10,x); return ans; } - private double naturalLog(double x){ + public double naturalLog(double x){ double ans = Math.log(x); return ans; } - private double inverseNaturalLog(double x){ + public double inverseNaturalLog(double x){ double ans = Math.exp(x); return ans; } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 94e8d987..99f420a0 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,7 +1,66 @@ package com.zipcodewilmington.scientific_calculator; +import com.zipcodewilmington.scientificcalculator.Calculator; + +import static org.junit.Assert.*; + /** * Created by leon on 2/9/18. */ public class TestMainApplication { + + @org.junit.Before + public void setUp() throws Exception { + } + + @org.junit.After + public void tearDown() throws Exception { + } + + @org.junit.Test + public void testAddition() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + assertEquals(Double.valueOf(100.0), myCalc.addition(79,21), 0.00001); + assertEquals(Double.valueOf(4.0), myCalc.addition(6,-2), 0.00001); + + } + + @org.junit.Test + public void testSubtraction() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.subtraction(6,2), 0.00001); + assertEquals(Double.valueOf(-20.0), myCalc.subtraction(70,90), 0.00001); + assertEquals(Double.valueOf(4.0), myCalc.subtraction(2,-2), 0.00001); + + } + + @org.junit.Test + public void testMultiply() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + + } + + @org.junit.Test + public void initial4() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + + } + + @org.junit.Test + public void initial5() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + + } + + @org.junit.Test + public void initial6() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + + } + } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplicationTest.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplicationTest.java new file mode 100644 index 00000000..05f7dfd4 --- /dev/null +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplicationTest.java @@ -0,0 +1,14 @@ +package com.zipcodewilmington.scientific_calculator; + +import static org.junit.jupiter.api.Assertions.*; + +class TestMainApplicationTest { + + @org.junit.jupiter.api.BeforeEach + void setUp() { + } + + @org.junit.jupiter.api.AfterEach + void tearDown() { + } +} \ No newline at end of file From 48c729cd8a923a3cbd2151b5292fcd5dd50f41e1 Mon Sep 17 00:00:00 2001 From: mike Date: Sat, 27 Feb 2021 17:59:25 -0500 Subject: [PATCH 09/16] add divide by zero changes. Changed DrawScreen to accept string --- .../scientificcalculator/Calculator.java | 95 ++++++++++++++++++- .../scientificcalculator/MainApplication.java | 40 ++++++-- 2 files changed, 124 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 289e0866..95fddfab 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -4,23 +4,62 @@ public class Calculator { public Calculator() { } - public void drawScreen(double d){ + public void drawScreen(String d){ + Console.println(""); Console.println("|------------------------------------------------|"); - Console.println("| Current Number: %s |",d); + Console.println("|Clear Memory |"); + Console.println("|------------------------------------------------|"); + Console.println("| Current Number: %s |",d); Console.println("|------------------------------------------------|"); Console.println("| Add Subtract Multiply Divide |"); Console.println("| Square Square Root Exponential Inverse |"); Console.println("| Log Log-1 Ln Ln-1 |"); Console.println("| Sine Cosine Tangent Factorial |"); - Console.println("| Sine-1 Cosine-1 Tangent-1 |"); + Console.println("| Sine-1 Cosine-1 Tangent-1 Invert |"); Console.println("|------------------------------------------------|"); } + public double performOperation(String op, double num1, double num2){ + double returnAns; + + if(op.equalsIgnoreCase("add")){ + returnAns = this.addition(num1,num2); + } + else if(op.equalsIgnoreCase("subtract")){ + returnAns = this.subtraction(num1,num2); + } + else if(op.equalsIgnoreCase("multiply")){ + returnAns = this.multiply(num1, num2); + } + else if(op.equalsIgnoreCase("divide")){ + returnAns = this.divide(num1, num2); + } + else if(op.equalsIgnoreCase("exponential")){ + returnAns = this.exponential(num1, num2); + } + //below is placeholder + else { + returnAns = 69; + } + return returnAns; + } public double performOperation(String op, double num){ double returnAns; - if(op.equalsIgnoreCase("sine")){ + if(op.equalsIgnoreCase("square")){ + returnAns = this.square(num); + } + else if(op.equalsIgnoreCase("square root")){ + returnAns = this.squareRoot(num); + } + else if(op.equalsIgnoreCase("inverse")){ + returnAns = this.inverse(num); + } + else if(op.equalsIgnoreCase("invert")){ + returnAns = this.invert(num); + } + else if(op.equalsIgnoreCase("sine")){ returnAns = this.sine(num); } else if(op.equalsIgnoreCase("cosine")){ @@ -60,6 +99,52 @@ else if(op.equalsIgnoreCase("ln-1")){ return returnAns; } + //two variable operations + private double addition(double x,double y){ + double ans = x + y; + return ans; + } + + private double subtraction(double x,double y){ + double ans = x - y; + return ans; + } + + private double multiply(double x,double y){ + double ans = x * y; + return ans; + } + + //NEED TO FIX DIVIDE BY ZERO + private double divide(double x,double y){ + double ans = x / y; + return ans; + } + + private double exponential(double x,double y){ + double ans = Math.pow(x,y); + return ans; + } + + //one variable operations + private double square(double x){ + double ans = Math.pow(x,2); + return ans; + } + private double squareRoot(double x){ + double ans = Math.sqrt(x); + return ans; + } + + private double inverse(double x){ + double ans = (1 / x); + return ans; + } + private double invert(double x){ + double ans = (x * -1); + return ans; + } + private double sine(double x){ double ans = Math.sin(x); return ans; @@ -132,4 +217,4 @@ private String err(){ return "Err"; } -} +} \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 4c0a33d1..8f63f7c2 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -5,16 +5,44 @@ */ public class MainApplication { public static void main(String[] args) { + double y; + double ans; + Console.println("Welcome to my calculator!"); - Double firstNum = Console.getDoubleInput("Please enter your first number or enter \"Memory\" for your stored value"); + y = Console.getDoubleInput("Please enter your first number or enter \"Memory\" for your stored value"); Calculator myCalc = new Calculator(); - myCalc.drawScreen(firstNum); - String op = Console.getStringInput("Please enter the operation you would like to perform:"); - double ans = myCalc.performOperation(op,firstNum); - myCalc.drawScreen(ans); + myCalc.drawScreen(Double.toString(y)); + + while(true) { + + String op = Console.getStringInput("Please enter the operation you would like to perform:"); + if (op.equalsIgnoreCase("clear")) { + ans = 0; + myCalc.drawScreen(Double.toString(ans)); + } else if (op.equalsIgnoreCase("add") || op.equalsIgnoreCase("subtract") || op.equalsIgnoreCase("multiply") || op.equalsIgnoreCase("exponential")) { + double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value"); + ans = myCalc.performOperation(op, y, secondNum); + myCalc.drawScreen(Double.toString(ans)); + } else if (op.equalsIgnoreCase("divide")){ + double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value"); + if (secondNum == 0) { + String error = "Can't divide by zero"; + myCalc.drawScreen(error); + } + else { + ans = myCalc.performOperation(op, y, secondNum); + myCalc.drawScreen(Double.toString(ans)); + } + } + else { + ans = myCalc.performOperation(op, y); + myCalc.drawScreen(Double.toString(ans)); + } + + } @@ -24,4 +52,4 @@ public static void main(String[] args) { //Console.println("The user input %s as a integer", i); } -} +} \ No newline at end of file From 1edaa46d067469ad9906a7ac5ff1754f8f4ee267 Mon Sep 17 00:00:00 2001 From: hazel Date: Sat, 27 Feb 2021 19:03:37 -0500 Subject: [PATCH 10/16] Added more tests --- .../scientificcalculator/Calculator.java | 43 +------ .../scientificcalculator/MainApplication.java | 18 --- .../TestMainApplication.java | 118 ++++++++++++++++-- 3 files changed, 112 insertions(+), 67 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 8b56c0d3..02f815af 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -100,94 +100,53 @@ else if(op.equalsIgnoreCase("ln-1")){ } //two variable operations -<<<<<<< HEAD - private double addition(double x,double y){ -======= - public double addition(double x,double y){ ->>>>>>> HazelBranch + public double addition(double x, double y){ double ans = x + y; return ans; } -<<<<<<< HEAD - private double subtraction(double x,double y){ -======= public double subtraction(double x,double y){ ->>>>>>> HazelBranch double ans = x - y; return ans; } -<<<<<<< HEAD - private double multiply(double x,double y){ -======= public double multiply(double x,double y){ ->>>>>>> HazelBranch double ans = x * y; return ans; } - //NEED TO FIX DIVIDE BY ZERO -<<<<<<< HEAD - private double divide(double x,double y){ -======= public double divide(double x,double y){ ->>>>>>> HazelBranch double ans = x / y; return ans; } -<<<<<<< HEAD - private double exponential(double x,double y){ -======= public double exponential(double x,double y){ ->>>>>>> HazelBranch double ans = Math.pow(x,y); return ans; } //one variable operations -<<<<<<< HEAD - private double square(double x){ - double ans = Math.pow(x,2); - return ans; - } - private double squareRoot(double x){ -======= public double square(double x){ double ans = Math.pow(x,2); return ans; } public double squareRoot(double x){ ->>>>>>> HazelBranch double ans = Math.sqrt(x); return ans; } -<<<<<<< HEAD - private double inverse(double x){ - double ans = (1 / x); - return ans; - } - private double invert(double x){ -======= public double inverse(double x){ double ans = (1 / x); return ans; } public double invert(double x){ ->>>>>>> HazelBranch double ans = (x * -1); return ans; } -<<<<<<< HEAD - private double sine(double x){ -======= public double sine(double x){ ->>>>>>> HazelBranch double ans = Math.sin(x); return ans; } diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 2a7eaf93..bccd4023 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -14,18 +14,13 @@ public static void main(String[] args) { Calculator myCalc = new Calculator(); -<<<<<<< HEAD myCalc.drawScreen(Double.toString(y)); -======= - myCalc.drawScreen(y); ->>>>>>> HazelBranch while(true) { String op = Console.getStringInput("Please enter the operation you would like to perform:"); if (op.equalsIgnoreCase("clear")) { ans = 0; -<<<<<<< HEAD myCalc.drawScreen(Double.toString(ans)); } else if (op.equalsIgnoreCase("add") || op.equalsIgnoreCase("subtract") || op.equalsIgnoreCase("multiply") || op.equalsIgnoreCase("exponential")) { double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value"); @@ -46,19 +41,6 @@ public static void main(String[] args) { ans = myCalc.performOperation(op, y); myCalc.drawScreen(Double.toString(ans)); } - -======= - } else if (op.equalsIgnoreCase("add") || op.equalsIgnoreCase("subtract") || op.equalsIgnoreCase("multiply") || op.equalsIgnoreCase("divide") || op.equalsIgnoreCase("exponential")) { - double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value"); - ans = myCalc.performOperation(op, y, secondNum); - } else { - ans = myCalc.performOperation(op, y); - } - - myCalc.drawScreen(ans); - y = ans; - ->>>>>>> HazelBranch } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 99f420a0..edf4f7ee 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -23,7 +23,6 @@ public void testAddition() { assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); assertEquals(Double.valueOf(100.0), myCalc.addition(79,21), 0.00001); assertEquals(Double.valueOf(4.0), myCalc.addition(6,-2), 0.00001); - } @org.junit.Test @@ -32,35 +31,140 @@ public void testSubtraction() { assertEquals(Double.valueOf(4.0), myCalc.subtraction(6,2), 0.00001); assertEquals(Double.valueOf(-20.0), myCalc.subtraction(70,90), 0.00001); assertEquals(Double.valueOf(4.0), myCalc.subtraction(2,-2), 0.00001); - } @org.junit.Test public void testMultiply() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + assertEquals(Double.valueOf(18.0), myCalc.multiply(6,3), 0.00001); + assertEquals(Double.valueOf(-4.0), myCalc.multiply(-2,2), 0.00001); + assertEquals(Double.valueOf(144.0), myCalc.multiply(12,12), 0.00001); + } + @org.junit.Test + public void testDivide() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(1.0), myCalc.divide(2,2), 0.00001); + assertEquals(Double.valueOf(2.0), myCalc.divide(8,4), 0.00001); + assertEquals(Double.valueOf(0.25), myCalc.divide(1,4), 0.00001); } @org.junit.Test - public void initial4() { + public void testExponential() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + assertEquals(Double.valueOf(9.0), myCalc.exponential(3,2), 0.00001); + assertEquals(Double.valueOf(8.0), myCalc.exponential(2,3), 0.00001); + assertEquals(Double.valueOf(1.0), myCalc.exponential(2,0), 0.00001); + } + @org.junit.Test + public void testSquare() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.square(2), 0.00001); + assertEquals(Double.valueOf(1.0), myCalc.square(1), 0.00001); + assertEquals(Double.valueOf(1600.0), myCalc.square(40), 0.00001); } @org.junit.Test - public void initial5() { + public void testSquareRoot() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + assertEquals(Double.valueOf(1.41421), myCalc.squareRoot(2), 0.00001); + assertEquals(Double.valueOf(2.0), myCalc.squareRoot(4), 0.00001); + assertEquals(Double.valueOf(4.0), myCalc.squareRoot(16), 0.00001); + } + + @org.junit.Test + public void testInverse() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(0.5), myCalc.inverse(2), 0.00001); + assertEquals(Double.valueOf(2.0), myCalc.inverse(0.5), 0.00001); + assertEquals(Double.valueOf(0.1), myCalc.inverse(10), 0.00001); + } + + @org.junit.Test + public void testInvert() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(-2.0), myCalc.invert(2), 0.00001); + assertEquals(Double.valueOf(3.0), myCalc.invert(-3), 0.00001); + assertEquals(Double.valueOf(0.0), myCalc.invert(0), 0.00001); + } + + @org.junit.Test + public void testSine() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(0), myCalc.sine(0), 0.00001); + assertEquals(Double.valueOf(0.84147), myCalc.sine(1), 0.00001); + assertEquals(Double.valueOf(0.9093), myCalc.sine(2), 0.00001); + } + + @org.junit.Test + public void testCosine() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(1.0), myCalc.cosine(0), 0.00001); + assertEquals(Double.valueOf(0.5403), myCalc.cosine(1), 0.00001); + assertEquals(Double.valueOf(-0.41615), myCalc.cosine(2), 0.00001); + } + + @org.junit.Test + public void testTangent() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(0.0), myCalc.tangent(0), 0.00001); + assertEquals(Double.valueOf(1.55741), myCalc.tangent(1), 0.00001); + assertEquals(Double.valueOf(-2.18504), myCalc.tangent(2), 0.00001); + } + + @org.junit.Test + public void testInverseSine() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.inverseSine(2), 0.00001); + } + + @org.junit.Test + public void testInverseCosine() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.inverseCosine(2), 0.00001); + } + + @org.junit.Test + public void testFactorial() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.factorial(2), 0.00001); + } + @org.junit.Test + public void testLog() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.log(2), 0.00001); + } + + @org.junit.Test + public void testInverseLog() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.inverseLog(2), 0.00001); + } + + @org.junit.Test + public void testNaturalLog() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.naturalLog(2), 0.00001); + } + + @org.junit.Test + public void testInverseNaturalLog() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.inverseNaturalLog(2), 0.00001); } @org.junit.Test public void initial6() { Calculator myCalc = new Calculator(); assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + } + @org.junit.Test + public void initial7() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); } } From 7d3e63ef76fdf4b1cedc8768012b6bc42123ed43 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Sun, 28 Feb 2021 10:06:30 -0500 Subject: [PATCH 11/16] Added convertBinary and convertHex --- .DS_Store | Bin 0 -> 6148 bytes src/.DS_Store | Bin 0 -> 6148 bytes src/main/.DS_Store | Bin 0 -> 6148 bytes src/main/java/.DS_Store | Bin 0 -> 6148 bytes src/main/java/com/.DS_Store | Bin 0 -> 6148 bytes src/main/java/com/zipcodewilmington/.DS_Store | Bin 0 -> 6148 bytes .../scientificcalculator/Calculator.java | 12 ++++++++++++ .../TestMainApplication.java | 5 +++++ 8 files changed, 17 insertions(+) create mode 100644 .DS_Store create mode 100644 src/.DS_Store create mode 100644 src/main/.DS_Store create mode 100644 src/main/java/.DS_Store create mode 100644 src/main/java/com/.DS_Store create mode 100644 src/main/java/com/zipcodewilmington/.DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..3767bd444a69d337a58a358a8315fa33f9788edc GIT binary patch literal 6148 zcmeHK!D`z;5S_K1WaU!gLm@ftrO<;3HZ5@=1QgdfBOIaEVjuO{Pa|jnc<>sI;1GK7 z3ULSXV!Pw>jN9Kbs*uAFE*7K2*27WJI3Gl*nd?V1NRzy1weCcvT3cJ+kg_i8kLw?T zOFa&Xuo>aQKdTCt-0JIs1*)>D&&Z)1*H>Ydm?Wvm#8g{?H^RaUVn8zfH1OkGp!5 z#krX$ume(h(mQKxPbTfoUQ@OAI@6|_bULl3dhvXBI`!n%)Aqsf`PJtyldscn--#Fe z2Jj;=vgvRJH)uE#J_W-p)!9e%%%W#ejLZNtzznR60e1k&M=M*A7h(pOfq#VoIv*4& zq3^J?XpRnS%oPB!hHfKh(@!JiD2Kko(jtza2%Cy%Q-!-?2%C<6<>GvYrA3<#!d*Uu zTUodpiZH9={K|xb@GWx73@`(W3{-8mLG}OW&-eeuBHgIhDRf}H8FfQz+S9YJD!>c$-vugE46egU>sc9)o zvNT&d_AgY=&w{L*HiFI}^>%~oBDD6NQt{9Z!u_b-J1Ng^sU!=cq}|cUQLBw1M+Z^T zQoV-iCaqM@RVPsVxdlZCBNge^RTtHVKf2DxPhn1Rm>Oqgz&?*HxY>;KP5 z++zlqfq%t-aGHLzflIP?>)7Jxu60pQQAsE+H#kf|Ltn)hOIPtCsuuLSWFUGLbA#wX P;U57_12@dTk23HES&3%A literal 0 HcmV?d00001 diff --git a/src/main/.DS_Store b/src/main/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..db469c4718e1406e520e296119ec83f409f73bd2 GIT binary patch literal 6148 zcmeHK!AiqG5Z!I7ZYyFAf<5LUc<7-;u>}!At%u%(h#pkh#1fwmA@U;MvWnwzrCKZ5m0ERDvd7hGxn%F|>`f+lvAI<_XtrjtOr0>-Ssq1%r_8C`>K8b6IABnF59VqgInFh`qMU4UAs1Y&>~_+19@ ze6T?g9fPSxb#%a>S^&TtxRrpde*FP$bO1UAQ;pyO;W`yir*hL`aML+(oeuMkiBC1^ zbjH=2VIA{kZaNfh8V_!(aK;^tG!g^Ez-I=q_XDx;{y+M;|5rgY5Cg=(Vlu#U4YyH; z+RWWLS0&!HHfS3Z1>;hUvlKAYRSdCs6&FF3fZs*~&@q^51P=)P2q+q8AO`-Ffe$+H BTJQh> literal 0 HcmV?d00001 diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..c7cbb6d118adf5d326d4f025afa581ae3b570f40 GIT binary patch literal 6148 zcmeHK!AiqG5Z!I7ZYp9Af*x}bJoM0_SV4qP_0XFT(SwR6wrC(`rA;jwEBOumBfr4U z(V5+8p;T`oSY}}MO=f2{%-gV=5kkmjzg-uiB7{(&hy@3RZv^L2r=&ohBA~=I^mQ2P z5T0;3mjA#2?p;w_3oY(i@x=b^!pz2}5mN|7g@fKb?ecqgA4k2kR{M~JVrg!EL8-DT zFO@I+TRrg8Ano^>LH7)wj)L?yB>PzFcx(sZNz@r!R#x_Pk_J)I>6+xI-GPwv(e%)oCkfaik? zis%vM7R}KCgJ}T(OW-yFw)y!7bkPCm5#|=b10roIpiPz3Vo2&8q)mr;kK%KSHeE>b zW>|;bEU810)OtwQgbV3ew;c^qF`KZahw8%xr!kcui`aOBj9(@0Q3lRi{Js_9|1!H56r-yGVldsby*Jp 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..11880b3cc6aada09c8bd7012a9542e14d8623818 GIT binary patch literal 6148 zcmeHKQEL-H5S~q=ZX#lYf_>ZHg_TYLOl8c9pk^39^ zkNgGx9Q|f@Q7%kW|sZ#*u5blHC|*xq8<@xC}XRG;Sa*|tQ*n_o-Lqq zH7sQ`p_+0kHloFG6B*!l_kb?&#-?;azrMe7_)0pZ3f}UtuqSC@Q$+Kp@*Mj3hZ9&= zs*u+6X{himofi4L8VtUx)>ix0?K@g`b@yKPeSBu?xJs(Ue4NbQ^3%(tI!lB7%G%=6 zPSV%;q(16x@7uCU@^UhB$$2(G$h$Xrnb~@57iBhgbz(oEbw_uOdOOSIaJ1Vu!`;!U zZk5LxfG{8oTnhu?Fw%FgWp!Cp7!U?-G6Q@*7${>Du<_`Q4h*gZ0JhKhkMD)K0!Fdz*4&H(p* zkRIRvFaF;DyC4~a0b$_(WI(kK;)5~v7Vg%KUGiOPpvO=aj%z$#roeDlF=F{D-hn!S Y->?CU0yZAufyj@5qd^8?;GZ(^6EA^lApigX literal 0 HcmV?d00001 diff --git a/src/main/java/com/zipcodewilmington/.DS_Store b/src/main/java/com/zipcodewilmington/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..79c39779a290e88f71d6ed2fc373153b230c9a14 GIT binary patch literal 6148 zcmeHKQEL-H5S~q=ZX#kH3ifed1RwH{pqPRPM_M2HCYAXA*b$+C$c~(}v-cQxoYTmkiN9(q3-)p~%PwYIdl4@2Clj&Q2dYM!wX|P{e zn_t>V`Z}A;k2>3Xwy2V Date: Sun, 28 Feb 2021 10:17:26 -0500 Subject: [PATCH 12/16] binaryConvert Hexconvert --- 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 6148 -> 6148 bytes 5 files changed, 0 insertions(+), 0 deletions(-) diff --git a/src/.DS_Store b/src/.DS_Store index df747d384e150359a5128ccaee526e148cf1e1ca..e2d3af3ed681a9829b9e0dd14798df468b79caf6 100644 GIT binary patch delta 20 bcmZoMXffDufr;JHOh>`c)L`>S!hG{}CS6egMUe&@ diff --git a/src/main/.DS_Store b/src/main/.DS_Store index db469c4718e1406e520e296119ec83f409f73bd2..b1f08e88b5eae3a7746cd5d1df8cb746b6aec5d3 100644 GIT binary patch delta 20 bcmZoMXffDufr;JHOh>`c)L`>S!hG{}CS6egMUe&@ diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store index c7cbb6d118adf5d326d4f025afa581ae3b570f40..89dfc5b4955d4bc9b210b8ac8b1ee253afd0a6b4 100644 GIT binary patch delta 20 bcmZoMXffDuhKb$MOh>`c)L`>vCPPsGMGyuJ delta 20 bcmZoMXffDuhKb$WLPx>S!hG{(CPPsGMNI}5 diff --git a/src/main/java/com/.DS_Store b/src/main/java/com/.DS_Store index 11880b3cc6aada09c8bd7012a9542e14d8623818..7faa5e2fc633bdd3b241fd59ef14d0de83b0f56b 100644 GIT binary patch delta 20 bcmZoMXffEp!pv@IrlVkJYOtA``KJf~H`oP6 delta 20 bcmZoMXffEp!pv@Np`&1EVZNE0`KJf~I28p@ diff --git a/src/main/java/com/zipcodewilmington/.DS_Store b/src/main/java/com/zipcodewilmington/.DS_Store index 79c39779a290e88f71d6ed2fc373153b230c9a14..977b66dd273116ecb5ae998fc2c2b363df6b572c 100644 GIT binary patch delta 20 bcmZoMXffCzz|3xGrlVkJYOq Date: Sun, 28 Feb 2021 11:43:22 -0500 Subject: [PATCH 13/16] Catching an error --- .../scientificcalculator/MainApplication.java | 15 ++++-- .../TestMainApplication.java | 52 ++++++++++++------- src/uml.puml | 27 ++++++++++ 3 files changed, 73 insertions(+), 21 deletions(-) create mode 100644 src/uml.puml diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index bccd4023..2eb23842 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,16 +1,25 @@ package com.zipcodewilmington.scientificcalculator; +import java.util.InputMismatchException; + /** * Created by leon on 2/9/18. */ public class MainApplication { public static void main(String[] args) { - double y; - double ans; + double y = 0; + double ans = 0; Console.println("Welcome to my calculator!"); + while(true) { + try { + y = Console.getDoubleInput("Please enter your first number or enter \"Memory\" for your stored value"); + break; + } catch (InputMismatchException e) { + Console.println("Please enter one number."); + } + } - y = Console.getDoubleInput("Please enter your first number or enter \"Memory\" for your stored value"); Calculator myCalc = new Calculator(); diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index edf4f7ee..98e386ba 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -116,55 +116,71 @@ public void testTangent() { @org.junit.Test public void testInverseSine() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.inverseSine(2), 0.00001); + assertEquals(Double.valueOf(-1.5708), myCalc.inverseSine(-1), 0.00001); + assertEquals(Double.valueOf(0.0), myCalc.inverseSine(0), 0.00001); + assertEquals(Double.valueOf(1.5708), myCalc.inverseSine(1), 0.00001); } @org.junit.Test public void testInverseCosine() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.inverseCosine(2), 0.00001); + assertEquals(Double.valueOf(3.14159), myCalc.inverseCosine(-1), 0.00001); + assertEquals(Double.valueOf(1.5708), myCalc.inverseCosine(0), 0.00001); + assertEquals(Double.valueOf(0.0), myCalc.inverseCosine(1), 0.00001); + } + + @org.junit.Test + public void testInverseTangent() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(-0.7854), myCalc.inverseTangent(-1), 0.00001); + assertEquals(Double.valueOf(0.0), myCalc.inverseTangent(0), 0.00001); + assertEquals(Double.valueOf(0.7854), myCalc.inverseTangent(1), 0.00001); } @org.junit.Test public void testFactorial() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.factorial(2), 0.00001); + assertEquals(Double.valueOf(2.0), myCalc.factorial(2), 0.00001); + assertEquals(Double.valueOf(6.0), myCalc.factorial(3), 0.00001); + assertEquals(Double.valueOf(362880.0), myCalc.factorial(9), 0.00001); } @org.junit.Test public void testLog() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.log(2), 0.00001); + assertEquals(Double.valueOf(0.0), myCalc.log(1), 0.00001); + assertEquals(Double.valueOf(0.30103), myCalc.log(2), 0.00001); + assertEquals(Double.valueOf(1.0), myCalc.log(10), 0.00001); } @org.junit.Test public void testInverseLog() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.inverseLog(2), 0.00001); + assertEquals(Double.valueOf(1.0), myCalc.inverseLog(0), 0.00001); + assertEquals(Double.valueOf(2.0), myCalc.inverseLog(0.30103), 0.00001); + assertEquals(Double.valueOf(10.0), myCalc.inverseLog(1), 0.00001); } @org.junit.Test public void testNaturalLog() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.naturalLog(2), 0.00001); + assertEquals(Double.valueOf(0.0), myCalc.naturalLog(1), 0.00001); + assertEquals(Double.valueOf(2.30259), myCalc.naturalLog(10), 0.00001); + assertEquals(Double.valueOf(0.69315), myCalc.naturalLog(2), 0.00001); } @org.junit.Test public void testInverseNaturalLog() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.inverseNaturalLog(2), 0.00001); + assertEquals(Double.valueOf(1.0), myCalc.inverseNaturalLog(0), 0.0001); + assertEquals(Double.valueOf(10.0), myCalc.inverseNaturalLog(2.30259), 0.0001); + assertEquals(Double.valueOf(2.0), myCalc.inverseNaturalLog(0.69315), 0.0001); } - @org.junit.Test - public void initial6() { - Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); - } - - @org.junit.Test - public void initial7() { - Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); - } + //@org.junit.Test + //public void initial6() { + // Calculator myCalc = new Calculator(); + // assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + //} } diff --git a/src/uml.puml b/src/uml.puml new file mode 100644 index 00000000..f2cda622 --- /dev/null +++ b/src/uml.puml @@ -0,0 +1,27 @@ +@startuml +'https://plantuml.com/class-diagram + +abstract class AbstractList +abstract AbstractCollection +interface List +interface Collection + +List <|-- AbstractList +Collection <|-- AbstractCollection + +Collection <|- List +AbstractCollection <|- AbstractList +AbstractList <|-- ArrayList + +class ArrayList { +Object[] elementData +size() +} + +enum TimeUnit { +DAYS +HOURS +MINUTES +} + +@enduml \ No newline at end of file From 63fe45bc11c3cfcd69718250353ca8cc770773cf Mon Sep 17 00:00:00 2001 From: hazel Date: Sun, 28 Feb 2021 21:51:20 -0500 Subject: [PATCH 14/16] Filled out UML and tests --- .../scientificcalculator/Calculator.java | 103 ++++++------ .../scientificcalculator/MainApplication.java | 107 ++++++++----- .../TestMainApplication.java | 146 +++++++++++++++++- src/uml.puml | 83 ++++++++-- 4 files changed, 320 insertions(+), 119 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index d15fd89e..239f385e 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -1,29 +1,30 @@ package com.zipcodewilmington.scientificcalculator; - public class Calculator { public Calculator() { } - public void drawScreen(String d){ - Console.println(""); Console.println("|------------------------------------------------|"); - Console.println("|Clear Memory |"); + Console.println("|Quit Clear Set M+ MC MRC |"); Console.println("|------------------------------------------------|"); - Console.println("| Current Number: %s |",d); + Console.println(" Current Number: %s ",d); Console.println("|------------------------------------------------|"); Console.println("| Add Subtract Multiply Divide |"); Console.println("| Square Square Root Exponential Inverse |"); Console.println("| Log Log-1 Ln Ln-1 |"); Console.println("| Sine Cosine Tangent Factorial |"); Console.println("| Sine-1 Cosine-1 Tangent-1 Invert |"); + Console.println("| cToF fToC LBtoKG KGtoLB |"); + Console.println("| radToDeg degToRad |"); Console.println("|------------------------------------------------|"); } public double performOperation(String op, double num1, double num2){ double returnAns; - if(op.equalsIgnoreCase("add")){ returnAns = this.addition(num1,num2); + + double newThing = MainApplication.getCurrent(); + } else if(op.equalsIgnoreCase("subtract")){ returnAns = this.subtraction(num1,num2); @@ -34,19 +35,14 @@ else if(op.equalsIgnoreCase("multiply")){ else if(op.equalsIgnoreCase("divide")){ returnAns = this.divide(num1, num2); } - else if(op.equalsIgnoreCase("exponential")){ - returnAns = this.exponential(num1, num2); - } - //below is placeholder + //catching exponential operation else { - returnAns = 69; + returnAns = this.exponential(num1, num2); } return returnAns; } - public double performOperation(String op, double num){ double returnAns; - if(op.equalsIgnoreCase("square")){ returnAns = this.square(num); } @@ -92,100 +88,90 @@ else if(op.equalsIgnoreCase("ln")){ else if(op.equalsIgnoreCase("ln-1")){ returnAns = this.inverseNaturalLog(num); } - //below is placeholder + else if(op.equalsIgnoreCase("lbToKg")){ + returnAns = this.convertLBtoKG(num); + } + else if(op.equalsIgnoreCase("kgtoLb")) { + returnAns = this.convertKGtoLB(num); + } + else if(op.equalsIgnoreCase("radtodeg")) { + returnAns = this.toDegrees(num); + } + else if(op.equalsIgnoreCase("degtorad")) { + returnAns = this.toRadians(num); + } + else if(op.equalsIgnoreCase("fToC")){ + returnAns = this.convertFtoC(num); + } + //catching convert C to F else { - returnAns = 69; + returnAns = this.convertCtoF(num); } return returnAns; } - //two variable operations public double addition(double x, double y){ double ans = x + y; return ans; } - public double subtraction(double x,double y){ double ans = x - y; return ans; } - public double multiply(double x,double y){ double ans = x * y; return ans; } - + //divide by zero handled in MainApplication public double divide(double x,double y){ double ans = x / y; return ans; } - public double exponential(double x,double y){ double ans = Math.pow(x,y); return ans; } - //one variable operations public double square(double x){ double ans = Math.pow(x,2); return ans; } - public double squareRoot(double x){ double ans = Math.sqrt(x); return ans; } - public double inverse(double x){ double ans = (1 / x); return ans; } - public double invert(double x){ double ans = (x * -1); return ans; } - public double sine(double x){ double ans = Math.sin(x); return ans; } - public double cosine(double x){ double ans = Math.cos(x); return ans; } - public double tangent(double x){ double ans = Math.tan(x); return ans; } - public double inverseSine(double x){ double ans = Math.asin(x); return ans; } - public double inverseCosine(double x){ double ans = Math.acos(x); return ans; } - public double inverseTangent(double x){ double ans = Math.atan(x); return ans; } - - public double toRadians(double x){ - double ans = Math.toRadians(x); - return ans; - } - - public double toDegrees(double x){ - double ans = Math.toDegrees(x); - return ans; - } - public double factorial(double x){ double ans = 1; for(int i=1;i<=x;i++){ @@ -193,41 +179,44 @@ public double factorial(double x){ } return ans; } - public double log(double x){ double ans = Math.log10(x); return ans; } - public double inverseLog(double x){ double ans = Math.pow(10,x); return ans; } - public double naturalLog(double x){ double ans = Math.log(x); return ans; } - public double inverseNaturalLog(double x){ double ans = Math.exp(x); return ans; } - - private String err(){ - return "Err"; + public double convertFtoC(double x) { + double fToC = (x - 32) / 1.8; + return fToC; } - - //Conversions - public double convertBinary(double x) { - double ans = double.toBinaryString(x); + public double convertCtoF(double x) { + double cToF = (x * 1.8) + 32; + return cToF; + } + public double convertLBtoKG(double x) { + double lbToKg = (x * 0.45359237); + return lbToKg; + } + public double convertKGtoLB(double x){ + double kgtoLb = (x * 2.20462262); + return kgtoLb ; + } + public double toRadians(double x){ + double ans = Math.toRadians(x); return ans; } - - public double convertHex(double x) { - double ans = double.toHexString(x); + public double toDegrees(double x){ + double ans = Math.toDegrees(x); return ans; } - - } \ No newline at end of file diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 2eb23842..39c8ba36 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,63 +1,92 @@ package com.zipcodewilmington.scientificcalculator; - import java.util.InputMismatchException; - /** * Created by leon on 2/9/18. */ public class MainApplication { + + public static double currentlyDisplayed; + public static void main(String[] args) { - double y = 0; - double ans = 0; + boolean isRunning = true; + Calculator myCalc = new Calculator(); + myCalc.drawScreen(Double.toString(currentlyDisplayed)); Console.println("Welcome to my calculator!"); while(true) { try { - y = Console.getDoubleInput("Please enter your first number or enter \"Memory\" for your stored value"); + currentlyDisplayed = Console.getDoubleInput("Please enter your first number:"); break; } catch (InputMismatchException e) { - Console.println("Please enter one number."); + Console.println(""); } } - - - Calculator myCalc = new Calculator(); - - myCalc.drawScreen(Double.toString(y)); - - while(true) { - + myCalc.drawScreen(Double.toString(currentlyDisplayed)); + while(isRunning) { String op = Console.getStringInput("Please enter the operation you would like to perform:"); - if (op.equalsIgnoreCase("clear")) { - ans = 0; - myCalc.drawScreen(Double.toString(ans)); - } else if (op.equalsIgnoreCase("add") || op.equalsIgnoreCase("subtract") || op.equalsIgnoreCase("multiply") || op.equalsIgnoreCase("exponential")) { - double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value"); - ans = myCalc.performOperation(op, y, secondNum); - myCalc.drawScreen(Double.toString(ans)); - } else if (op.equalsIgnoreCase("divide")){ - double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value"); - if (secondNum == 0) { - String error = "Can't divide by zero"; - myCalc.drawScreen(error); + //prompt user for second number if they choose two variable operator then run two variable operator + if (op.equalsIgnoreCase("add") || op.equalsIgnoreCase("subtract") || op.equalsIgnoreCase("multiply") || op.equalsIgnoreCase("exponential")) { + while(true){ + try{ + double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value:"); + currentlyDisplayed = myCalc.performOperation(op,currentlyDisplayed, secondNum); + myCalc.drawScreen(Double.toString(currentlyDisplayed)); + break; + } + catch(InputMismatchException e) { + Console.println(""); + } } - else { - ans = myCalc.performOperation(op, y, secondNum); - myCalc.drawScreen(Double.toString(ans)); + } + //handle division by zero + else if (op.equalsIgnoreCase("divide")){ + while(true){ + try{ + double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value:"); + if (secondNum == 0) { + String error = "Can't divide by zero"; + myCalc.drawScreen(error); + } + else { + currentlyDisplayed = myCalc.performOperation(op, currentlyDisplayed, secondNum); + myCalc.drawScreen(Double.toString(currentlyDisplayed)); + } + break; + } + catch(InputMismatchException e) { + Console.println(""); + } } } - else { - ans = myCalc.performOperation(op, y); - myCalc.drawScreen(Double.toString(ans)); + //run one variable operator + else if (op.equalsIgnoreCase("square") || op.equalsIgnoreCase("square root") || op.equalsIgnoreCase("inverse") || op.equalsIgnoreCase("log")|| op.equalsIgnoreCase("log-1")|| op.equalsIgnoreCase("ln")|| op.equalsIgnoreCase("ln-1")|| op.equalsIgnoreCase("sine")|| op.equalsIgnoreCase("cosine")|| op.equalsIgnoreCase("tangent")|| op.equalsIgnoreCase("factorial")|| op.equalsIgnoreCase("sine-1")|| op.equalsIgnoreCase("cosine-1")|| op.equalsIgnoreCase("tangent-1")|| op.equalsIgnoreCase("invert")|| op.equalsIgnoreCase("ctof")|| op.equalsIgnoreCase("ftoc")|| op.equalsIgnoreCase("lbtokg")|| op.equalsIgnoreCase("kgtolb")|| op.equalsIgnoreCase("radtodeg")|| op.equalsIgnoreCase("degtorad")){ + currentlyDisplayed = myCalc.performOperation(op, currentlyDisplayed); + myCalc.drawScreen(Double.toString(currentlyDisplayed)); + } + //clear screen + else if (op.equalsIgnoreCase("clear")) { + currentlyDisplayed = 0; + myCalc.drawScreen(Double.toString(currentlyDisplayed)); + } + else if(op.equalsIgnoreCase("set")){ + double setNum = Console.getDoubleInput("Please enter your number to set:"); + currentlyDisplayed = setNum; + myCalc.drawScreen(Double.toString(currentlyDisplayed)); + } + //quit calc + else if(op.equalsIgnoreCase("quit")){ + isRunning = false; + } + //handle misspelled operator + else{ + String error = "Invalid operator"; + myCalc.drawScreen(error); } } + } - - - - //Console.println("The user input %s as a string", s); - //Console.println("The user input %s as a d", d); - //Console.println("The user input %s as a integer", i); - + public static double getCurrent(){ + return currentlyDisplayed; } + } \ 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 index 562fc920..ba10a3da 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -177,15 +177,147 @@ public void testInverseNaturalLog() { assertEquals(Double.valueOf(2.0), myCalc.inverseNaturalLog(0.69315), 0.0001); } - //@org.junit.Test - //public void initial6() { - // Calculator myCalc = new Calculator(); - // assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); - //} + @org.junit.Test + public void testConvertFtoC() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(32.22222), myCalc.convertFtoC(90), 0.0001); + assertEquals(Double.valueOf(5), myCalc.convertFtoC(41), 0.0001); + assertEquals(Double.valueOf(-17.77778), myCalc.convertFtoC(0), 0.0001); + } @org.junit.Test - public void testConvertBinary() { + public void testConvertCtoF() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(10), myCalc.convertBinary(2)); + assertEquals(Double.valueOf(90), myCalc.convertCtoF(32.22222), 0.0001); + assertEquals(Double.valueOf(41), myCalc.convertCtoF(5), 0.0001); + assertEquals(Double.valueOf(0), myCalc.convertCtoF(-17.77778), 0.0001); } + + @org.junit.Test + public void testConvertLBtoKG() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(0.45359), myCalc.convertLBtoKG(1), 0.0001); + assertEquals(Double.valueOf(10.43262), myCalc.convertLBtoKG(23), 0.0001); + assertEquals(Double.valueOf(206.8381), myCalc.convertLBtoKG(456), 0.0001); + } + + @org.junit.Test + public void testConvertKGtoLB() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(1), myCalc.convertKGtoLB(0.45359), 0.0001); + assertEquals(Double.valueOf(23), myCalc.convertKGtoLB(10.43262), 0.0001); + assertEquals(Double.valueOf(456), myCalc.convertKGtoLB(206.8381), 0.0001); + } + + @org.junit.Test + public void testToRadians() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(0), myCalc.toRadians(0), 0.0001); + assertEquals(Double.valueOf(1.5708), myCalc.toRadians(90), 0.0001); + assertEquals(Double.valueOf(3.14159), myCalc.toRadians(180), 0.0001); + } + + @org.junit.Test + public void testToDegrees() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(0), myCalc.toDegrees(0), 0.001); + assertEquals(Double.valueOf(90), myCalc.toDegrees(1.5708), 0.001); + assertEquals(Double.valueOf(180), myCalc.toDegrees(3.14159), 0.001); + } + + /*@org.junit.Test + public void testDecToBinary() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(10), myCalc.decToBinary(2)); + assertEquals(Double.valueOf(1), myCalc.decToBinary(1)); + assertEquals(Double.valueOf(1000), myCalc.decToBinary(8)); + } + + @org.junit.Test + public void testDecToOct() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(2), myCalc.decToOct(2)); + assertEquals(Double.valueOf(10), myCalc.decToOct(8)); + assertEquals(Double.valueOf(170), myCalc.decToOct(120)); + } + + @org.junit.Test + public void testDecToHex() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(2), myCalc.decToHex(2)); + assertEquals(Double.valueOf(14), myCalc.decToHex(20)); + assertEquals("1f", myCalc.decToHex(31)); + } + + @org.junit.Test + public void testBinaryToDec() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(2), myCalc.binaryToDec(10)); + assertEquals(Double.valueOf(1), myCalc.binaryToDec(1)); + assertEquals(Double.valueOf(8), myCalc.binaryToDec(1000)); + } + + @org.junit.Test + public void testBinaryToOct() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(2), myCalc.binaryToOct(10)); + assertEquals(Double.valueOf(17), myCalc.binaryToOct(1111)); + assertEquals(Double.valueOf(10), myCalc.binaryToOct(1000)); + } + + @org.junit.Test + public void testBinaryToHex() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(2), myCalc.binaryToHex(10)); + assertEquals(Double.valueOf(10), myCalc.binaryToHex(10000)); + assertEquals("1f", myCalc.binaryToHex(11111)); + } + + @org.junit.Test + public void testOctToBinary() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(10), myCalc.octToBinary(2)); + assertEquals(Double.valueOf(1), myCalc.octToBinary(1)); + assertEquals(Double.valueOf(1000), myCalc.octToBinary(10)); + } + + @org.junit.Test + public void testOctToDec() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(2), myCalc.octToDec(2)); + assertEquals(Double.valueOf(8), myCalc.octToDec(10)); + assertEquals(Double.valueOf(120), myCalc.octToDec(170)); + } + + @org.junit.Test + public void testOctToHex() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(2), myCalc.octToHex(2)); + assertEquals("e", myCalc.octToHex(16)); + assertEquals(Double.valueOf(19), myCalc.octToHex(31)); + } + + @org.junit.Test + public void testHexToBinary() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(2), myCalc.hexToBinary(2)); + assertEquals(Double.valueOf(15), myCalc.hexToBinary("f")); + assertEquals(Double.valueOf(171), myCalc.hexToBinary("ab")); + } + + @org.junit.Test + public void testHexToOct() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(2), myCalc.hexToOct(2)); + assertEquals(Double.valueOf(17), myCalc.hexToOct("f")); + assertEquals(Double.valueOf(252), myCalc.hexToOct("ab")); + } + + @org.junit.Test + public void testHexToDec() { + Calculator myCalc = new Calculator(); + assertEquals(Double.valueOf(10), myCalc.hexToDec(2)); + assertEquals(Double.valueOf(1111), myCalc.hexToDec("f")); + assertEquals(Double.valueOf(10101011), myCalc.hexToDec("ab")); + }*/ } diff --git a/src/uml.puml b/src/uml.puml index f2cda622..16a9b84f 100644 --- a/src/uml.puml +++ b/src/uml.puml @@ -1,27 +1,78 @@ @startuml 'https://plantuml.com/class-diagram -abstract class AbstractList -abstract AbstractCollection -interface List -interface Collection +'abstract class AbstractList +'abstract AbstractCollection +'interface List +'interface Collection -List <|-- AbstractList -Collection <|-- AbstractCollection +class MainApplication{ + double currentlyDisplayed + boolean isRunning -Collection <|- List -AbstractCollection <|- AbstractList -AbstractList <|-- ArrayList -class ArrayList { -Object[] elementData -size() } -enum TimeUnit { -DAYS -HOURS -MINUTES +class Console{ + getStringInput() + getDoubleInput() } +class Calculator{ + drawScreen() + performOperation(String, double, double) + performOperation(String, double) + addition() + subtraction() + multiply() + divide() + exponential() + square() + squareRoot() + inverse() + invert() + sine() + cosine() + tangent() + inverseSine() + inverseCosine() + inverseTangent() + factorial() + log() + inverseLog() + naturalLog() + inverseNaturalLog() + convertFtoC() + convertCtoF() + convertLBtoKG() + convertKGtoLB() + toRadians() + toDegrees() + decToBinary() + decToOct() + decToHex() + binaryToDec() + binaryToOct() + binaryToHex() + octToBinary() + octToDec() + octToHex() + hexToBinary() + hexToOct() + hexToDec() +} + +'List <|-- AbstractList +'Collection <|-- AbstractCollection + +MainApplication <|-- Console +MainApplication <|-- Calculator + +'class ArrayList { +'Object[] elementData +'size() +'} + + + @enduml \ No newline at end of file From 552c569e903557898e8984952ff1fa1503bb75ca Mon Sep 17 00:00:00 2001 From: hazel Date: Sun, 28 Feb 2021 21:56:32 -0500 Subject: [PATCH 15/16] Updated UML --- src/uml.puml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/uml.puml b/src/uml.puml index 16a9b84f..29f500dd 100644 --- a/src/uml.puml +++ b/src/uml.puml @@ -8,6 +8,7 @@ class MainApplication{ double currentlyDisplayed + double memory boolean isRunning From 239a1dfa76f1a5b5f93488a91f49cc04e9a56953 Mon Sep 17 00:00:00 2001 From: hazel Date: Sun, 28 Feb 2021 22:16:52 -0500 Subject: [PATCH 16/16] Cleaned up UML --- src/uml.puml | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/src/uml.puml b/src/uml.puml index 29f500dd..79af28ee 100644 --- a/src/uml.puml +++ b/src/uml.puml @@ -1,17 +1,9 @@ @startuml -'https://plantuml.com/class-diagram - -'abstract class AbstractList -'abstract AbstractCollection -'interface List -'interface Collection class MainApplication{ double currentlyDisplayed double memory boolean isRunning - - } class Console{ @@ -63,16 +55,9 @@ class Calculator{ hexToDec() } -'List <|-- AbstractList -'Collection <|-- AbstractCollection - MainApplication <|-- Console MainApplication <|-- Calculator -'class ArrayList { -'Object[] elementData -'size() -'}