Fixed bug using .equals()

Shuvamdt · Shuvamdt · commit a5fc3db6404f · 2023-12-23T23:32:55.000+05:30
diff --git a/src/simplejavacalculator/Calculator.java b/src/simplejavacalculator/Calculator.java
@@ -30,26 +30,26 @@ public enum MonoOperatorModes {
     private BiOperatorModes mode = BiOperatorModes.normal;
 
     private Double calculateBiImpl() {
-        if (mode == BiOperatorModes.normal) {
+        if (mode.equals(BiOperatorModes.normal)) {
             return num2;
         }
-        if (mode == BiOperatorModes.add) {
+        if (mode.equals(BiOperatorModes.add)) {
             if (num2 != 0) {
                 return num1 + num2;
             }
 
             return num1;
         }
-        if (mode == BiOperatorModes.minus) {
+        if (mode.equals(BiOperatorModes.minus)) {
             return num1 - num2;
         }
-        if (mode == BiOperatorModes.multiply) {
+        if (mode.equals(BiOperatorModes.multiply)) {
             return num1 * num2;
         }
-        if (mode == BiOperatorModes.divide) {
+        if (mode.equals(BiOperatorModes.divide)) {
             return num1 / num2;
         }
-        if (mode == BiOperatorModes.xpowerofy) {
+        if (mode.equals(BiOperatorModes.xpowerofy)) {
             return pow(num1,num2);
         }
 
@@ -58,7 +58,7 @@ private Double calculateBiImpl() {
     }
 
     public Double calculateBi(BiOperatorModes newMode, Double num) {
-        if (mode == BiOperatorModes.normal) {
+        if (mode.equals(BiOperatorModes.normal)) {
             num2 = 0.0;
             num1 = num;
             mode = newMode;
@@ -85,41 +85,41 @@ public Double reset() {
 
     
     public Double calculateMono(MonoOperatorModes newMode, Double num) {
-        if (newMode == MonoOperatorModes.square) {
+        if (newMode.equals(MonoOperatorModes.square)) {
             return num * num;
         }
-        if (newMode == MonoOperatorModes.squareRoot) {
+        if (newMode.equals(MonoOperatorModes.squareRoot)) {
             return Math.sqrt(num);
         }
-        if (newMode == MonoOperatorModes.oneDividedBy) {
+        if (newMode.equals(MonoOperatorModes.oneDividedBy)) {
             return 1 / num;
         }
-        if (newMode == MonoOperatorModes.cos) {
+        if (newMode.equals(MonoOperatorModes.cos)) {
             return Math.cos(Math.toRadians(num));
         }
-        if (newMode == MonoOperatorModes.sin) {
+        if (newMode.equals(MonoOperatorModes.sin)) {
             return Math.sin(Math.toRadians(num));
         }
-        if (newMode == MonoOperatorModes.tan) {
-            if (num == 0 || num % 180 == 0) {
+        if (newMode.equals(MonoOperatorModes.tan)) {
+            if (num == 0 || num % 180 == 0 ) {
                 return 0.0;
             }
-            if (num % 90 == 0 && num % 180 != 0) {
+            if (num % 90 == 0.0 && num % 180 != 0.0) {
                 return NaN;
             }
 
             return Math.tan(Math.toRadians(num));
         }
-        if (newMode == MonoOperatorModes.log) {
+        if (newMode.equals(MonoOperatorModes.log)) {
             return log10(num);
         }
-        if (newMode == MonoOperatorModes.ln) {
+        if (newMode.equals(MonoOperatorModes.ln)) {
             return log(num);
         }
-        if (newMode == MonoOperatorModes.rate) {
-           return num / 100;
+        if (newMode.equals(MonoOperatorModes.rate) ) {
+            return num / 100;
         }
-        if (newMode == MonoOperatorModes.abs){
+        if (newMode.equals(MonoOperatorModes.abs)){
             return Math.abs(num);
         }
 
@@ -128,3 +128,4 @@ public Double calculateMono(MonoOperatorModes newMode, Double num) {
     }
 
 }
+

Original file line number	Diff line number	Diff line change
`@@ -30,26 +30,26 @@ public enum MonoOperatorModes {`
`30`	`30`	`private BiOperatorModes mode = BiOperatorModes.normal;`
`31`	`31`
`32`	`32`	`private Double calculateBiImpl() {`
`33`		`- if (mode == BiOperatorModes.normal) {`
	`33`	`+ if (mode.equals(BiOperatorModes.normal)) {`
`34`	`34`	`return num2;`
`35`	`35`	`}`
`36`		`- if (mode == BiOperatorModes.add) {`
	`36`	`+ if (mode.equals(BiOperatorModes.add)) {`
`37`	`37`	`if (num2 != 0) {`
`38`	`38`	`return num1 + num2;`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`return num1;`
`42`	`42`	`}`
`43`		`- if (mode == BiOperatorModes.minus) {`
	`43`	`+ if (mode.equals(BiOperatorModes.minus)) {`
`44`	`44`	`return num1 - num2;`
`45`	`45`	`}`
`46`		`- if (mode == BiOperatorModes.multiply) {`
	`46`	`+ if (mode.equals(BiOperatorModes.multiply)) {`
`47`	`47`	`return num1 * num2;`
`48`	`48`	`}`
`49`		`- if (mode == BiOperatorModes.divide) {`
	`49`	`+ if (mode.equals(BiOperatorModes.divide)) {`
`50`	`50`	`return num1 / num2;`
`51`	`51`	`}`
`52`		`- if (mode == BiOperatorModes.xpowerofy) {`
	`52`	`+ if (mode.equals(BiOperatorModes.xpowerofy)) {`
`53`	`53`	`return pow(num1,num2);`
`54`	`54`	`}`
`55`	`55`
`@@ -58,7 +58,7 @@ private Double calculateBiImpl() {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`public Double calculateBi(BiOperatorModes newMode, Double num) {`
`61`		`- if (mode == BiOperatorModes.normal) {`
	`61`	`+ if (mode.equals(BiOperatorModes.normal)) {`
`62`	`62`	`num2 = 0.0;`
`63`	`63`	`num1 = num;`
`64`	`64`	`mode = newMode;`
`@@ -85,41 +85,41 @@ public Double reset() {`
`85`	`85`
`86`	`86`
`87`	`87`	`public Double calculateMono(MonoOperatorModes newMode, Double num) {`
`88`		`- if (newMode == MonoOperatorModes.square) {`
	`88`	`+ if (newMode.equals(MonoOperatorModes.square)) {`
`89`	`89`	`return num * num;`
`90`	`90`	`}`
`91`		`- if (newMode == MonoOperatorModes.squareRoot) {`
	`91`	`+ if (newMode.equals(MonoOperatorModes.squareRoot)) {`
`92`	`92`	`return Math.sqrt(num);`
`93`	`93`	`}`
`94`		`- if (newMode == MonoOperatorModes.oneDividedBy) {`
	`94`	`+ if (newMode.equals(MonoOperatorModes.oneDividedBy)) {`
`95`	`95`	`return 1 / num;`
`96`	`96`	`}`
`97`		`- if (newMode == MonoOperatorModes.cos) {`
	`97`	`+ if (newMode.equals(MonoOperatorModes.cos)) {`
`98`	`98`	`return Math.cos(Math.toRadians(num));`
`99`	`99`	`}`
`100`		`- if (newMode == MonoOperatorModes.sin) {`
	`100`	`+ if (newMode.equals(MonoOperatorModes.sin)) {`
`101`	`101`	`return Math.sin(Math.toRadians(num));`
`102`	`102`	`}`
`103`		`- if (newMode == MonoOperatorModes.tan) {`
`104`		`- if (num == 0 \|\| num % 180 == 0) {`
	`103`	`+ if (newMode.equals(MonoOperatorModes.tan)) {`
	`104`	`+ if (num == 0 \|\| num % 180 == 0 ) {`
`105`	`105`	`return 0.0;`
`106`	`106`	`}`
`107`		`- if (num % 90 == 0 && num % 180 != 0) {`
	`107`	`+ if (num % 90 == 0.0 && num % 180 != 0.0) {`
`108`	`108`	`return NaN;`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`return Math.tan(Math.toRadians(num));`
`112`	`112`	`}`
`113`		`- if (newMode == MonoOperatorModes.log) {`
	`113`	`+ if (newMode.equals(MonoOperatorModes.log)) {`
`114`	`114`	`return log10(num);`
`115`	`115`	`}`
`116`		`- if (newMode == MonoOperatorModes.ln) {`
	`116`	`+ if (newMode.equals(MonoOperatorModes.ln)) {`
`117`	`117`	`return log(num);`
`118`	`118`	`}`
`119`		`- if (newMode == MonoOperatorModes.rate) {`
`120`		`- return num / 100;`
	`119`	`+ if (newMode.equals(MonoOperatorModes.rate) ) {`
	`120`	`+ return num / 100;`
`121`	`121`	`}`
`122`		`- if (newMode == MonoOperatorModes.abs){`
	`122`	`+ if (newMode.equals(MonoOperatorModes.abs)){`
`123`	`123`	`return Math.abs(num);`
`124`	`124`	`}`
`125`	`125`
`@@ -128,3 +128,4 @@ public Double calculateMono(MonoOperatorModes newMode, Double num) {`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`}`
	`131`	`+`