From 28cd444f5bee713b7c0447f49cc7e83ea3127723 Mon Sep 17 00:00:00 2001 From: Chris Allen Date: Fri, 26 Feb 2021 17:29:21 -0500 Subject: [PATCH 01/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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/20] 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 10:58:09 -0500 Subject: [PATCH 13/20] added rolling conversion display and specific conversion display --- .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 .../scientificcalculator/Calculator.java | 42 ++++++++++++++++++ 6 files changed, 42 insertions(+) diff --git a/.DS_Store b/.DS_Store index 3767bd444a69d337a58a358a8315fa33f9788edc..d06b1fda088f2df5fffdd9a2782864e146618160 100644 GIT binary patch delta 20 bcmZoMXffEJ!_01JrlVkJYOvXu`JxB_I)DXk delta 20 bcmZoMXffEJ!_01Op`&1EVZPaz`JxB_I=uyW diff --git a/src/main/.DS_Store b/src/main/.DS_Store index b1f08e88b5eae3a7746cd5d1df8cb746b6aec5d3..17ed69a0473eb3a99b8ea18591ea2ee14e6c8d58 100644 GIT binary patch delta 46 zcmZoMXffE}&BSE;>rAqYGbVp!l4qQ`S(Nz`%Vsu?fBXPi CI}Yvu delta 97 zcmZoMXffE}&BS(r$lwNp{1FQf}yEFt&T#qxw(Okf{C$NZ7nBM8XF_ge hRdr2m-Ao2BU}S{Q4E#_UM$OtR!u*M4Gdss$egKpF6t@5X diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store index 89dfc5b4955d4bc9b210b8ac8b1ee253afd0a6b4..b86f938a9604ea8c41bad98db0766220f7105f8d 100644 GIT binary patch delta 70 zcmZoMXffE}&ct|PvIkRxhInM8XF_ge bRdr2m-OR}!nB*B}Z5Cku#DTZf04=8Iv`cDTab{V@8Iw(!M8XF_ge lRdr2m-Ao2BU}S{Q4E#_UM$MYc!=$shfw_%kGdss$egG2b76bqQ diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index d15fd89e..78794d04 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -99,6 +99,40 @@ else if(op.equalsIgnoreCase("ln-1")){ return returnAns; } + public double switchDisplayMode(String convert, double num) { + double returnans; + if (convert.equalsIgnoreCase("Switch Display binary")){ + returnans = this.convertBinary(num); + } else if (convert.equalsIgnoreCase("switch display hex")) { + returnans = this.convertHex(num); + } else if (convert.equalsIgnoreCase("switch display octal")) { + returnans = this.convertOctal(num); + } else if (convert.equalsIgnoreCase("switch display decimal")) { + returnans = this.convertDecimal(num); + } else { + returnans = num; + } + return returnans; + } + + public double rotateDisplaySwitch (String convert, double num) { + double returnans; + if (convert.equalsIgnoreCase("switch display")) { + if (num == this.convertDecimal(num)) { + returnans = this.convertBinary(num); + } else if (num == this.convertBinary(num)) { + returnans = this.convertOctal(num); + } else if (num == this.convertOctal(num)) { + returnans = this.convertHex(num); + } else if (num = this.convertHex(num)) { + returnans = this.convertDecimal(num); + } else { + return returnans = num; + } + return returnans; + } + } + //two variable operations public double addition(double x, double y){ double ans = x + y; @@ -229,5 +263,13 @@ public double convertHex(double x) { return ans; } + public double convertOctal(double x) { + double ans = double.toOctalString(x); + return ans; + } + public double convertDecimal(double x) { + double ans = double.parseInt(x); + return ans; + } } \ No newline at end of file From c7fa9a7923f3fa443849a47f48dd9115d37c0da2 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Sun, 28 Feb 2021 11:52:09 -0500 Subject: [PATCH 14/20] Added test classes for the conversions --- .../scientificcalculator/Calculator.java | 16 +++++------ .../TestMainApplication.java | 28 ++++++++++++++++++- 2 files changed, 35 insertions(+), 9 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 78794d04..fc2d5b73 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -253,23 +253,23 @@ private String err(){ } //Conversions - public double convertBinary(double x) { - double ans = double.toBinaryString(x); + public String convertBinary(double x) { + String ans = double.toBinaryString(x); return ans; } - public double convertHex(double x) { - double ans = double.toHexString(x); + public String convertHex(double x) { + String ans = double.toHexString(x); return ans; } - public double convertOctal(double x) { - double ans = double.toOctalString(x); + public String convertOctal(double x) { + String ans = double.toOctalString(x); return ans; } - public double convertDecimal(double x) { - double ans = double.parseInt(x); + public double convertDecimal(String x) { + double ans = String.parseInt(x); return ans; } } \ 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 7bfa12c9..10db3797 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -170,6 +170,32 @@ public void initial7() { @org.junit.Test public void testConvertBinary() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(10), myCalc.convertBinary(2)); + assertEquals("10110", myCalc.convertBinary(22)); //Decimal + assertEquals("10110", myCalc.convertBinary("16")); //Hex + assertEquals("10110", myCalc.convertBinary("26")); //Octal + } + + @org.junit.Test + public void testConvertHex() { + Calculator myCalc = new Calculator(); + assertEquals("2B", myCalc.convertHex(43)); //Decimal + assertEquals("2B", myCalc.convertHex("53")); //Octal + assertEquals("2B", myCalc.convertHex("101011")); //Binary + } + + @org.junit.Test + public void testConvertOctal() { + Calculator myCalc = new Calculator(); + assertEquals("14", myCalc.convertOctal(12)); //Decimal + assertEquals("14", myCalc.convertOctal("C")); //Hex + assertEquals("14", myCalc.convertOctal("1100")); //Binary + } + + @org.junit.Test + public void testConvertDecimal() { + Calculator myCalc = new Calculator(); + assertEquals(94, myCalc.convertDecimal("5E")); //Hex + assertEquals(94, myCalc.convertDecimal("136")); //Octal + assertEquals(94, myCalc.convertDecimal("1011110")); //Binary } } From 472fa53c595135f3bc03b92ac1253b36315cfbc6 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Sun, 28 Feb 2021 14:01:03 -0500 Subject: [PATCH 15/20] merged Chris's code with my conversions and memory pieces --- .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 6148 -> 6148 bytes .../scientificcalculator/Calculator.java | 53 ++++++++++++++---- .../TestMainApplication.java | 3 + 8 files changed, 44 insertions(+), 12 deletions(-) diff --git a/.DS_Store b/.DS_Store index d06b1fda088f2df5fffdd9a2782864e146618160..5cc8a1037eaeda362b206b0943ee0972d53bde88 100644 GIT binary patch delta 21 ccmZoMXffEJ&CFqBYO14PWM;nEnE9dz06$d)qyPW_ delta 21 ccmZoMXffEJ&CFqFX{MuKXlk(8nE9dz06$6vp8x;= diff --git a/src/.DS_Store b/src/.DS_Store index e2d3af3ed681a9829b9e0dd14798df468b79caf6..e153a0a255f10cd3c37db53acc9d0abf817ddeb5 100644 GIT binary patch delta 21 ccmZoMXffDuo{7WA)Ko{o$jp56btYX=07}dTM*si- delta 21 ccmZoMXffDuo{7WI(o9Fe(9~e_btYX=07}6ILI3~& diff --git a/src/main/.DS_Store b/src/main/.DS_Store index 17ed69a0473eb3a99b8ea18591ea2ee14e6c8d58..7bb43dbf3a7688b5f577e22f1dd92ee69260704b 100644 GIT binary patch delta 97 zcmZoMXffE}&BS(r$lwNk*TSUf{~edt&T#qxw(Okf{C$NZ7nBM8XF_ge hRdr2m-Ao2BU}S{Q4E#_UM$OtR!u*M4Gdss$egKtL6ubZc delta 46 zcmZoMXffE}&BSE;>rAqYGbVp!l4qQ`S(Nz`%Vsu?fBXPi CI}Yvu diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store index b86f938a9604ea8c41bad98db0766220f7105f8d..fb256c808aec888a12a64dce13519bcf567e04e3 100644 GIT binary patch delta 71 zcmZoMXffE}&ct|fvIkRxrbKnMk*TSUf{~edt&T#qxw(Okf{C$NZ7nBM8XF_ge bRdr2m-OR}!nB*B}Z5Cku#DTZf04=8Iv`cM8XF_ge lRdr2m-Ao2BU}S{Q4E#_UM$MYc!=$shfw_%kGdss$egF}R761SM delta 50 zcmZoMXffE(&BSDTab{V@8Iw(! Date: Sun, 28 Feb 2021 14:56:45 -0500 Subject: [PATCH 16/20] updated Main Application from Chris --- .../scientificcalculator/Calculator.java | 12 +- .../scientificcalculator/MainApplication.java | 105 +++++++++++------- 2 files changed, 73 insertions(+), 44 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 72119c2b..8aca245a 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -133,15 +133,15 @@ public double rotateDisplaySwitch (String convert, double num) { //store, recall, and clear memory public double memoryUsage(String inputStr, double x) { - double memory; - if (inputStr.equalsIgnoreCase("m+")) { + double memory = 0; + if (inputStr.equalsIgnoreCase("M+")) { memory = this.calcMemory(x); } else if (inputStr.equalsIgnoreCase("MC")){ - memory = null; - } else if (inputStr.equalsIgnoreCase("MRC") && memory != null) { + memory = 0; + } else if (inputStr.equalsIgnoreCase("MRC")) { return memory; } else { - memory = null; + memory = 0; } return memory; } @@ -270,7 +270,7 @@ public double convertFtoC(double x) { double fToC = (x - 32) / 1.8; return fToC; } - + public double convertCtoF(double x) { double cToF = (x * 1.8) + 32; return cToF; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index bccd4023..20fee79a 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -1,54 +1,83 @@ 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 currentlyDisplayed; + boolean isRunning = true; Console.println("Welcome to my calculator!"); - - y = Console.getDoubleInput("Please enter your first number or enter \"Memory\" for your stored value"); - - Calculator myCalc = new Calculator(); - - myCalc.drawScreen(Double.toString(y)); - while(true) { - + try { + currentlyDisplayed = Console.getDoubleInput("Please enter your first number:"); + break; + } catch (InputMismatchException e) { + Console.println("Please enter one number."); + } + } + Calculator myCalc = new Calculator(); + 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")){ + 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); - } } \ No newline at end of file From b5450a6fe83f083394968a07b75962189d33e3f0 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Sun, 28 Feb 2021 17:06:35 -0500 Subject: [PATCH 17/20] Added Chris's updates to Main Application and Calculator. Has Greg's display change options and methods in. --- src/main/java/com/zipcodewilmington/.DS_Store | Bin 6148 -> 6148 bytes .../scientificcalculator/Calculator.java | 56 +++++++++++++----- .../scientificcalculator/MainApplication.java | 15 ++--- 3 files changed, 50 insertions(+), 21 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/.DS_Store b/src/main/java/com/zipcodewilmington/.DS_Store index e1c8f2a6514de846fd927c458ce22537667e1002..210e6866e78ce1b07e6ce254b9649f1deb36ae83 100644 GIT binary patch delta 20 bcmZoMXffCzz|3x8qN8AFY_M6J`K<^5ICKR~ delta 20 bcmZoMXffCzz|3xJqN8AFWVTtH`K<^5I8_Br diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index 8aca245a..ff0e50d9 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -5,16 +5,17 @@ public Calculator() { public void drawScreen(String d){ Console.println(""); Console.println("|------------------------------------------------|"); - Console.println("|Quit 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 |"); + Console.println("| cToF fToC LBtoKG KGtoLB |"); + Console.println("| radToDeg degToRad |"); Console.println("|------------------------------------------------|"); } public double performOperation(String op, double num1, double num2){ @@ -97,7 +98,33 @@ else if(op.equalsIgnoreCase("ln-1")){ } //Conversion conditionals - public double switchDisplayMode(String convert, double num) { + public double displayMode(double x, String y) { + double returnAns; + if (y.equalsIgnoreCase("switch display binary")) { + returnAns = this.convertBinary(x); + } else if (y.equalsIgnoreCase("switch display hexadecimal")) { + returnAns = this.convertHex(x); + } else if (y.equalsIgnoreCase("switch display octal")) { + returnAns = this.convertOctal(x); + } else if (y.equalsIgnoreCase("switch display decimal")) { + returnAns = x; + } else { + //catches Switch Display + if (x) { + returnAns = this.convertBinary(x); + } else if (y == this.convertBinary(x)) { + returnAns = this.convertOctal(x); + } else if (y == this.convertOctal(x)) { + returnAns = this.convertHex(x); + } else { + //catches if it's Hex + returnAns = x; + } + return returnAns; + } + } + /*public double switchDisplayMode(String convert, double num) { + double returnans; if (convert.equalsIgnoreCase("Switch Display binary")){ returnans = this.convertBinary(num); @@ -129,7 +156,7 @@ public double rotateDisplaySwitch (String convert, double num) { } return returnans; } - } + }*/ //store, recall, and clear memory public double memoryUsage(String inputStr, double x) { @@ -277,25 +304,26 @@ public double convertCtoF(double x) { } //Conversions + public String convertBinary(double x) { - String ans = double.toBinaryString(x); - return ans; + String ans = double.toBinaryString(x); + return ans; } public String convertHex(double x) { - String ans = double.toHexString(x); - return ans; + String ans = double.toHexString(x); + return ans; } public String convertOctal(double x) { - String ans = double.toOctalString(x); - return ans; + String ans = double.toOctalString(x); + return ans; } - public double convertDecimal(String x) { - double ans = String.parseInt(x); + /*public double convertDecimal(String x, Integer radix) { + double ans = Integer.parseInt(x, radix); return ans; - } + }*/ public double calcMemory(double x) { double memory = x; diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index 20fee79a..d2767ecf 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -5,18 +5,19 @@ */ public class MainApplication { public static void main(String[] args) { - double currentlyDisplayed; + double currentlyDisplayed = 0; boolean isRunning = true; + Calculator myCalc = new Calculator(); + myCalc.drawScreen(Double.toString(currentlyDisplayed)); Console.println("Welcome to my calculator!"); while(true) { try { 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(currentlyDisplayed)); while(isRunning) { String op = Console.getStringInput("Please enter the operation you would like to perform:"); @@ -24,7 +25,7 @@ public static void main(String[] args) { 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"); + 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; @@ -38,7 +39,7 @@ public static void main(String[] args) { else if (op.equalsIgnoreCase("divide")){ while(true){ try{ - double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value"); + 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); @@ -55,7 +56,7 @@ else if (op.equalsIgnoreCase("divide")){ } } //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")){ + 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)); } @@ -65,7 +66,7 @@ else if (op.equalsIgnoreCase("clear")) { myCalc.drawScreen(Double.toString(currentlyDisplayed)); } else if(op.equalsIgnoreCase("set")){ - double setNum = Console.getDoubleInput("Please enter your number to set"); + double setNum = Console.getDoubleInput("Please enter your number to set:"); currentlyDisplayed = setNum; myCalc.drawScreen(Double.toString(currentlyDisplayed)); } From dadf9bf23327227cbaf76b4831ef8672387bc7e4 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Sun, 28 Feb 2021 22:12:47 -0500 Subject: [PATCH 18/20] Should be the most up to date version of the calculator --- .../scientificcalculator/Calculator.java | 176 +++++++++------- .../scientificcalculator/MainApplication.java | 76 ++++++- .../TestMainApplication.java | 195 ++++++++++++------ 3 files changed, 303 insertions(+), 144 deletions(-) diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java index ff0e50d9..5143ffe9 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/Calculator.java @@ -2,6 +2,7 @@ public class Calculator { public Calculator() { } + private double memory; public void drawScreen(String d){ Console.println(""); Console.println("|------------------------------------------------|"); @@ -15,6 +16,10 @@ public void drawScreen(String d){ Console.println("| Sine Cosine Tangent Factorial |"); Console.println("| Sine-1 Cosine-1 Tangent-1 Invert |"); Console.println("| cToF fToC LBtoKG KGtoLB |"); + Console.println("| decToBinary decToOct decToHex |"); + Console.println("| octToBinary octToDec octToHex |"); + Console.println("| hexToBinary hexToOct hextoDec |"); + Console.println("| binaryToDec binaryToOct binaryToHex |"); Console.println("| radToDeg degToRad |"); Console.println("|------------------------------------------------|"); } @@ -97,66 +102,6 @@ else if(op.equalsIgnoreCase("ln-1")){ return returnAns; } - //Conversion conditionals - public double displayMode(double x, String y) { - double returnAns; - if (y.equalsIgnoreCase("switch display binary")) { - returnAns = this.convertBinary(x); - } else if (y.equalsIgnoreCase("switch display hexadecimal")) { - returnAns = this.convertHex(x); - } else if (y.equalsIgnoreCase("switch display octal")) { - returnAns = this.convertOctal(x); - } else if (y.equalsIgnoreCase("switch display decimal")) { - returnAns = x; - } else { - //catches Switch Display - if (x) { - returnAns = this.convertBinary(x); - } else if (y == this.convertBinary(x)) { - returnAns = this.convertOctal(x); - } else if (y == this.convertOctal(x)) { - returnAns = this.convertHex(x); - } else { - //catches if it's Hex - returnAns = x; - } - return returnAns; - } - } - /*public double switchDisplayMode(String convert, double num) { - - double returnans; - if (convert.equalsIgnoreCase("Switch Display binary")){ - returnans = this.convertBinary(num); - } else if (convert.equalsIgnoreCase("switch display hex")) { - returnans = this.convertHex(num); - } else if (convert.equalsIgnoreCase("switch display octal")) { - returnans = this.convertOctal(num); - } else if (convert.equalsIgnoreCase("switch display decimal")) { - returnans = this.convertDecimal(num); - } else { - returnans = num; - } - return returnans; - } - - public double rotateDisplaySwitch (String convert, double num) { - double returnans; - if (convert.equalsIgnoreCase("switch display")) { - if (num == this.convertDecimal(num)) { - returnans = this.convertBinary(num); - } else if (num == this.convertBinary(num)) { - returnans = this.convertOctal(num); - } else if (num == this.convertOctal(num)) { - returnans = this.convertHex(num); - } else if (num = this.convertHex(num)) { - returnans = this.convertDecimal(num); - } else { - return returnans = num; - } - return returnans; - } - }*/ //store, recall, and clear memory public double memoryUsage(String inputStr, double x) { @@ -303,30 +248,101 @@ public double convertCtoF(double x) { return cToF; } - //Conversions - - public String convertBinary(double x) { - String ans = double.toBinaryString(x); - return ans; - } - - public String convertHex(double x) { - String ans = double.toHexString(x); - return ans; + public double calcMemory(double x) { + double memory = x; + return memory; } - public String convertOctal(double x) { - String ans = double.toOctalString(x); - return ans; + //conversions + public String decimalToBinary(double x){ + int conversionInt = (int)x; + String ans = Integer.toString(conversionInt,2); + return ans; } - - /*public double convertDecimal(String x, Integer radix) { - double ans = Integer.parseInt(x, radix); + public String decimalToHex(double x){ + int conversionInt = (int)x; + String ans = Integer.toString(conversionInt,16); return ans; - }*/ - - public double calcMemory(double x) { - double memory = x; + } + public double decimalToOct(double x){ + String octStr = Integer.toOctalString((int) x); + double octNum = Integer.parseInt(octStr); + return octNum; + } + public double octalToHex (double x) { + String stringOct = String.valueOf(x); + double decNum = Integer.parseInt(stringOct, 8); + String hexStr = Integer.toHexString((int)decNum); + double hexNum = Integer.parseInt(hexStr); + return hexNum; + } + public double octalToBinary (double x) { + String stringOct = String.valueOf(x); + double decNum = Integer.parseInt(stringOct, 8); + String binStr = Integer.toHexString((int)decNum); + double binNum = Integer.parseInt(binStr); + return binNum; + } + public double octalToDecimal (double x) { + String stringOct = String.valueOf(x); + double decNum = Integer.parseInt(stringOct, 8); + return decNum; + } + public double hexToOctal (double x) { + String stringHex = String.valueOf(x); + double hexNum = Integer.parseInt(stringHex, 16); + String octStr = Integer.toOctalString((int)hexNum); + double octNum = Integer.parseInt(octStr); + return octNum; + } + public double hexToBinary (double x) { + String stringHex = String.valueOf(x); + double hexNum = Integer.parseInt(stringHex, 16); + String binStr = Integer.toBinaryString((int)hexNum); + double binNum = Integer.parseInt(binStr); + return binNum; + } + public double hexToDecimal (double x) { + String stringHex = String.valueOf(x); + double decNum = Integer.parseInt(stringHex, 8); + return decNum; + } + public double binToDec (double x) { + String stringBin = String.valueOf(x); + double decNum = Integer.parseInt(stringBin, 2); + return decNum; + } + public double binaryToOct (double x) { + String stringBin = String.valueOf(x); + double binNum = Integer.parseInt(stringBin, 2); + String octStr = Integer.toBinaryString((int)binNum); + double octNum = Integer.parseInt(octStr); + return octNum; + } + public double binaryToHex (double x) { + String stringBin = String.valueOf(x); + double binNum = Integer.parseInt(stringBin, 2); + String hexStr = Integer.toBinaryString((int)binNum); + double hexNum = Integer.parseInt(hexStr); + return hexNum; + } + 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 memAdd(double x){ + memory = x; + return memory; + } + public double memClear(){ + memory = 0; + return memory; + } + public double memRecall(){ return memory; } } \ 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 d2767ecf..d8736743 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -19,13 +19,14 @@ public static void main(String[] args) { } } myCalc.drawScreen(Double.toString(currentlyDisplayed)); + while(isRunning) { String op = Console.getStringInput("Please enter the operation you would like to perform:"); //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:"); + double secondNum = Console.getDoubleInput("Please enter your second number:"); currentlyDisplayed = myCalc.performOperation(op,currentlyDisplayed, secondNum); myCalc.drawScreen(Double.toString(currentlyDisplayed)); break; @@ -39,7 +40,7 @@ public static void main(String[] args) { else if (op.equalsIgnoreCase("divide")){ while(true){ try{ - double secondNum = Console.getDoubleInput("Please enter your second number or enter \"Memory\" for your stored value:"); + double secondNum = Console.getDoubleInput("Please enter your second number:"); if (secondNum == 0) { String error = "Can't divide by zero"; myCalc.drawScreen(error); @@ -60,8 +61,75 @@ else if (op.equalsIgnoreCase("square") || op.equalsIgnoreCase("square root") || currentlyDisplayed = myCalc.performOperation(op, currentlyDisplayed); myCalc.drawScreen(Double.toString(currentlyDisplayed)); } - //clear screen - else if (op.equalsIgnoreCase("clear")) { + //memory add + else if(op.equalsIgnoreCase("m+")){ + myCalc.memAdd(currentlyDisplayed); + String message = currentlyDisplayed + " added to memory"; + myCalc.drawScreen(message); + } + //memory clear + else if(op.equalsIgnoreCase("mc")){ + myCalc.memClear(); + String message = "Memory reset to 0"; + myCalc.drawScreen(message); + } + //memory recall + else if(op.equalsIgnoreCase("mrc")){ + currentlyDisplayed = myCalc.memRecall(); + myCalc.drawScreen(Double.toString(currentlyDisplayed)); + + //conversions + } else if (op.equalsIgnoreCase("dectobinary")) { + String stringBinary = myCalc.decimalToBinary(currentlyDisplayed); + currentlyDisplayed = Double.parseDouble(stringBinary); + myCalc.drawScreen(stringBinary); + } else if (op.equalsIgnoreCase("dectohex")) { + String stringBinary = myCalc.decimalToHex(currentlyDisplayed); + currentlyDisplayed = Double.parseDouble(stringBinary); + myCalc.drawScreen(stringBinary); + } else if (op.equalsIgnoreCase("dectooct")) { + double stringBinary = myCalc.decimalToOct(currentlyDisplayed); + String strDecToOct = String.valueOf(stringBinary); + myCalc.drawScreen(strDecToOct); + } else if (op.equalsIgnoreCase("octtohex")) { + double stringOctToHex = myCalc.octalToHex(currentlyDisplayed); + String stringToHex = String.valueOf(stringOctToHex); + myCalc.drawScreen(stringToHex); + } else if (op.equalsIgnoreCase("octtobinary")) { + double numOctToBinary = myCalc.octalToBinary(currentlyDisplayed); + String stringToBinary = String.valueOf(numOctToBinary); + myCalc.drawScreen(stringToBinary); + } else if (op.equalsIgnoreCase("octtodec")) { + double octToDec = myCalc.octalToDecimal(currentlyDisplayed); + String stringToDecimal = String.valueOf(octToDec); + myCalc.drawScreen((stringToDecimal)); + } else if (op.equalsIgnoreCase("hexToBinary")) { + double hexToBin = myCalc.hexToBinary(currentlyDisplayed); + String stringToBinary = String.valueOf(hexToBin); + myCalc.drawScreen(stringToBinary); + } else if (op.equalsIgnoreCase("hextodec")) { + double hexToDec = myCalc.hexToDecimal(currentlyDisplayed); + String stringToDecimal = String.valueOf(hexToDec); + myCalc.drawScreen(stringToDecimal); + }else if (op.equalsIgnoreCase("hextooct")) { + double hexToOct = myCalc.hexToOctal(currentlyDisplayed); + String stringToOct = String.valueOf(hexToOct); + myCalc.drawScreen(stringToOct); + } else if (op.equalsIgnoreCase("binaryToDec")) { + double binToDec = myCalc.binToDec(currentlyDisplayed); + String stringToDec = String.valueOf(binToDec); + myCalc.drawScreen(stringToDec); + } else if (op.equalsIgnoreCase("binaryToOct")) { + double bitToOct = myCalc.binaryToOct(currentlyDisplayed); + String stringToOct = String.valueOf(bitToOct); + myCalc.drawScreen(stringToOct); + } else if (op.equalsIgnoreCase("binaryToHex")) { + double bitToHex = myCalc.binaryToHex(currentlyDisplayed); + String stringToHex = String.valueOf(bitToHex); + myCalc.drawScreen(stringToHex); + + //Clear screen + }else if (op.equalsIgnoreCase("clear")) { currentlyDisplayed = 0; myCalc.drawScreen(Double.toString(currentlyDisplayed)); } diff --git a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java index 9238ec8c..fbbd81e7 100644 --- a/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java +++ b/src/test/java/com/zipcodewilmington/scientific_calculator/TestMainApplication.java @@ -1,22 +1,16 @@ 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(); @@ -24,7 +18,6 @@ public void testAddition() { 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(); @@ -32,7 +25,6 @@ public void testSubtraction() { 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(); @@ -40,7 +32,6 @@ public void testMultiply() { 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(); @@ -48,7 +39,6 @@ public void testDivide() { 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 testExponential() { Calculator myCalc = new Calculator(); @@ -56,7 +46,6 @@ public void testExponential() { 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(); @@ -64,7 +53,6 @@ public void testSquare() { 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 testSquareRoot() { Calculator myCalc = new Calculator(); @@ -72,7 +60,6 @@ public void testSquareRoot() { 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(); @@ -80,7 +67,6 @@ public void testInverse() { 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(); @@ -88,7 +74,6 @@ public void testInvert() { 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(); @@ -96,7 +81,6 @@ public void testSine() { 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(); @@ -104,7 +88,6 @@ public void testCosine() { 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(); @@ -112,93 +95,185 @@ public void testTangent() { 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); + 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 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 initial6() { + public void testConvertCtoF() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + 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 initial7() { + public void testConvertLBtoKG() { Calculator myCalc = new Calculator(); - assertEquals(Double.valueOf(4.0), myCalc.addition(2,2), 0.00001); + 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 testConvertBinary() { + public void testOctToBinary() { Calculator myCalc = new Calculator(); - assertEquals("10110", myCalc.convertBinary(22)); //Decimal - assertEquals("10110", myCalc.convertBinary("16")); //Hex - assertEquals("10110", myCalc.convertBinary("26")); //Octal + 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 testConvertHex() { + public void testOctToDec() { Calculator myCalc = new Calculator(); - assertEquals("2B", myCalc.convertHex(43)); //Decimal - assertEquals("2B", myCalc.convertHex("53")); //Octal - assertEquals("2B", myCalc.convertHex("101011")); //Binary + 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 testConvertOctal() { + public void testOctToHex() { Calculator myCalc = new Calculator(); - assertEquals("14", myCalc.convertOctal(12)); //Decimal - assertEquals("14", myCalc.convertOctal("C")); //Hex - assertEquals("14", myCalc.convertOctal("1100")); //Binary + assertEquals(Double.valueOf(2), myCalc.octToHex(2)); + assertEquals("e", myCalc.octToHex(16)); + assertEquals(Double.valueOf(19), myCalc.octToHex(31)); } - @org.junit.Test - public void testConvertDecimal() { + public void testHexToBinary() { Calculator myCalc = new Calculator(); - assertEquals(94, myCalc.convertDecimal("5E")); //Hex - assertEquals(94, myCalc.convertDecimal("136")); //Octal - assertEquals(94, myCalc.convertDecimal("1011110")); //Binary + 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 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")); + }*/ +} \ No newline at end of file From 571d7220964b71a8b558fce2f1ffd05c42d90ca1 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Sun, 28 Feb 2021 22:24:40 -0500 Subject: [PATCH 19/20] Up to date and UML included --- .DS_Store | Bin 6148 -> 6148 bytes src/main/java/com/zipcodewilmington/.DS_Store | Bin 6148 -> 6148 bytes .../scientificcalculator/MainApplication.java | 2 +- 3 files changed, 1 insertion(+), 1 deletion(-) diff --git a/.DS_Store b/.DS_Store index 5cc8a1037eaeda362b206b0943ee0972d53bde88..824d9d57dfc743872cfb84ca53e359ed6fe5fce1 100644 GIT binary patch delta 208 zcmZoMXfc=|#>B!ku~2NHo+2ar#(>?7ix)66F|tqQVM=zEWGH4xX2@hnWyoVF0n%we zoXijp#EA?!K(Z7_CIV&h8HyP6fO5GEIi5NB$w@i+Nem1O0t^g{t&Hmlles)IT#rjn1G5HHb;o8VFm!$Z8Ti~ delta 142 zcmZoMXfc=|#>B)qu~2NHo+2ab#(>?7jI5J+Sdu3nWU*j8Ir$e$1FJ-JwUO!M23BSB znG9gS$Oxes_@Ok6ngwJqGZZrvF(j7-7v<&T=cNNh7&i-Yh_Os;$lA=#!OsD-4aon_ UJegm_kprX=Xc)`p2$40+0Dhz#0ssI2 diff --git a/src/main/java/com/zipcodewilmington/.DS_Store b/src/main/java/com/zipcodewilmington/.DS_Store index 210e6866e78ce1b07e6ce254b9649f1deb36ae83..2e00b41037c820aa01adc6069112514e881ef0dc 100644 GIT binary patch delta 14 VcmZoMXffCz$joTIS%~?Q2mm0U1Tz2t delta 14 VcmZoMXffCz$joT6S%~?Q2mm0C1TX*q diff --git a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java index d8736743..8f9bb210 100644 --- a/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java +++ b/src/main/java/com/zipcodewilmington/scientificcalculator/MainApplication.java @@ -77,7 +77,7 @@ else if(op.equalsIgnoreCase("mc")){ else if(op.equalsIgnoreCase("mrc")){ currentlyDisplayed = myCalc.memRecall(); myCalc.drawScreen(Double.toString(currentlyDisplayed)); - + //conversions } else if (op.equalsIgnoreCase("dectobinary")) { String stringBinary = myCalc.decimalToBinary(currentlyDisplayed); From 5e46cc134a207976a374fa881a32e312cb29fe6a Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Sun, 28 Feb 2021 22:25:22 -0500 Subject: [PATCH 20/20] Most up to date and has UML --- src/uml.puml | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 src/uml.puml diff --git a/src/uml.puml b/src/uml.puml new file mode 100644 index 00000000..79af28ee --- /dev/null +++ b/src/uml.puml @@ -0,0 +1,64 @@ +@startuml + +class MainApplication{ + double currentlyDisplayed + double memory + boolean isRunning +} + +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() +} + +MainApplication <|-- Console +MainApplication <|-- Calculator + + + + +@enduml \ No newline at end of file