Merge pull request #56 from bartlomiej-gora/#55-rounding

#55 rounding
bartgora · Jul 14, 2017 · ef0dd5d · ef0dd5d
2 parents ac3ece9 + 62faaf4
commit ef0dd5d
Show file tree

Hide file tree

Showing 15 changed files with 91 additions and 48 deletions.
diff --git a/README.md b/README.md
@@ -59,12 +59,22 @@ Maven:
 
 Changelog:
 ====
+
+### Version 3.1.1-SNAPSHOT:
+
+- Fixed bug in divide operator, that caused:
+ ex: "10/4 = 2, and not 2.5",
+ "5/2 = 2, and not 2.5"
+- Changed RoundinMode from HALF_UP, to HALF_EVEN
+- Changed internal calculation type from BigDecimal to Double
+
+
 ### Version 3.1.0:
 
 
 
-Added package pl.bgora.rpn.advanced</br>
-Added AdvancedCalculatorFactory</br>
+- Added package pl.bgora.rpn.advanced</br>
+- Added AdvancedCalculatorFactory</br>
 
 
 The advanced Calculator works with CalculationEngine, which uses strategy pattern to run.

diff --git a/pom.xml b/pom.xml
@@ -6,7 +6,7 @@
 	<modelVersion>4.0.0</modelVersion>
     <groupId>com.github.bartlomiej-gora</groupId>
 	<artifactId>RPNLibrary</artifactId>
-    <version>3.2.0</version>
+    <version>3.2.1-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <distributionManagement>

diff --git a/src/main/java/com/github/bgora/rpnlibrary/DefaultExecutioner.java b/src/main/java/com/github/bgora/rpnlibrary/DefaultExecutioner.java
@@ -53,15 +53,15 @@ public BigDecimal executeOperator(String operator, String var1, String var2, Rou
     }
 
     private BigDecimal div(String var1, String var2, RoundingMode mode) {
-        BigDecimal big1 = new BigDecimal(var1);
-        BigDecimal big2 = new BigDecimal(var2);
-        return big1.divide(big2, mode);
+        Double big1 = new Double(var1);
+        Double big2 = new Double(var2);
+        return BigDecimal.valueOf(big1 / big2);
     }
 
     private BigDecimal mull(String var1, String var2) {
-        BigDecimal big1 = new BigDecimal(var1);
-        BigDecimal big2 = new BigDecimal(var2);
-        return big1.multiply(big2);
+        Double big1 = new Double(var1);
+        Double big2 = new Double(var2);
+        return BigDecimal.valueOf(big1*big2);
     }
 
     private BigDecimal sub(String var1, String var2) {

diff --git a/src/main/java/com/github/bgora/rpnlibrary/advanced/AdvancedCalculatorFactory.java b/src/main/java/com/github/bgora/rpnlibrary/advanced/AdvancedCalculatorFactory.java
@@ -35,7 +35,7 @@ public class AdvancedCalculatorFactory extends AbstractCalculatorFactory {
 
     public CalculatorInterface createCalulator() {
         CalculationEngine engine = getDefaultEngine();
-        return new AdvancedCalculator(RoundingMode.HALF_UP, engine);
+        return new AdvancedCalculator(RoundingMode.HALF_EVEN, engine);
     }
 
     /**
@@ -45,7 +45,7 @@ public CalculatorInterface createCalulator() {
      * @return AdvanceCalculator
      */
     public CalculatorInterface createCalulator(CalculationEngine engine) {
-        return new AdvancedCalculator(RoundingMode.HALF_UP, engine);
+        return new AdvancedCalculator(RoundingMode.HALF_EVEN, engine);
     }
 
 

diff --git a/src/main/java/com/github/bgora/rpnlibrary/advanced/functions/CosinusFunctionStrategy.java b/src/main/java/com/github/bgora/rpnlibrary/advanced/functions/CosinusFunctionStrategy.java
@@ -34,8 +34,8 @@ public CosinusFunctionStrategy() {
 
     @Override
     public BigDecimal execute(String... params) {
-        BigDecimal param = new BigDecimal(params[0]);
-        BigDecimal result = BigDecimal.valueOf(Math.cos(param.doubleValue()));
+        Double param = new Double(params[0]);
+        BigDecimal result = BigDecimal.valueOf(Math.cos(param));
         return result;
     }
 

diff --git a/src/main/java/com/github/bgora/rpnlibrary/advanced/functions/CtgFunctionStrategy.java b/src/main/java/com/github/bgora/rpnlibrary/advanced/functions/CtgFunctionStrategy.java
@@ -37,9 +37,9 @@ public CtgFunctionStrategy() {
 
     @Override
     public BigDecimal execute(String... params) {
-        BigDecimal dec = new BigDecimal(params[0]);
-        BigDecimal tan = BigDecimal.valueOf(Math.tan(dec.doubleValue()));
-        BigDecimal one = new BigDecimal(ONE);
-        return one.divide(tan, roundingMode);
+        Double dec = new Double(params[0]);
+        Double tan = Math.tan(dec.doubleValue());
+        Double one = new Double(1);
+        return BigDecimal.valueOf(one / tan);
     }
 }
diff --git a/src/main/java/com/github/bgora/rpnlibrary/advanced/functions/SinusFunctionStrategy.java b/src/main/java/com/github/bgora/rpnlibrary/advanced/functions/SinusFunctionStrategy.java
@@ -37,8 +37,8 @@ public SinusFunctionStrategy() {
      */
     @Override
     public BigDecimal execute(String... params) {
-        BigDecimal param = new BigDecimal(params[0]);
-        BigDecimal result = BigDecimal.valueOf(Math.sin(param.doubleValue()));
+        Double param = new Double(params[0]);
+        BigDecimal result = BigDecimal.valueOf(Math.sin(param));
         return result;
     }
 

diff --git a/src/main/java/com/github/bgora/rpnlibrary/advanced/functions/TanFunctionStrategy.java b/src/main/java/com/github/bgora/rpnlibrary/advanced/functions/TanFunctionStrategy.java
@@ -35,7 +35,7 @@ public TanFunctionStrategy() {
 
     @Override
     public BigDecimal execute(String... params) {
-        BigDecimal dec = new BigDecimal(params[0]);
-        return BigDecimal.valueOf(Math.tan(dec.doubleValue()));
+        Double dec = new Double(params[0]);
+        return BigDecimal.valueOf(Math.tan(dec));
     }
 }
diff --git a/src/main/java/com/github/bgora/rpnlibrary/advanced/operators/DivideOperatorStrategy.java b/src/main/java/com/github/bgora/rpnlibrary/advanced/operators/DivideOperatorStrategy.java
@@ -31,9 +31,9 @@ public DivideOperatorStrategy() {
 
     @Override
     public BigDecimal execute(String first, String second) {
-        BigDecimal big1 = new BigDecimal(first);
-        BigDecimal big2 = new BigDecimal(second);
-        return big1.divide(big2, roundingMode);
+        Double big1 = new Double(first);
+        Double big2 = new Double(second);
+        return BigDecimal.valueOf(big1/big2);
     }
 
 

diff --git a/src/main/java/com/github/bgora/rpnlibrary/advanced/operators/MiltiplyOperatorStrategy.java b/src/main/java/com/github/bgora/rpnlibrary/advanced/operators/MiltiplyOperatorStrategy.java
@@ -31,9 +31,9 @@ public MiltiplyOperatorStrategy() {
 
     @Override
     public BigDecimal execute(String first, String second) {
-        BigDecimal big1 = new BigDecimal(first);
-        BigDecimal big2 = new BigDecimal(second);
-        return big1.multiply(big2);
+        Double big1 = new Double(first);
+        Double big2 = new Double(second);
+        return BigDecimal.valueOf(big1 * big2);
     }
 
 

diff --git a/src/main/java/com/github/bgora/rpnlibrary/advanced/operators/PowerOperatorStrategy.java b/src/main/java/com/github/bgora/rpnlibrary/advanced/operators/PowerOperatorStrategy.java
@@ -31,9 +31,9 @@ public PowerOperatorStrategy() {
 
     @Override
     public BigDecimal execute(String first, String second) {
-        BigDecimal big1 = new BigDecimal(first);
-        BigDecimal big2 = new BigDecimal(second);
-        return big1.pow(big2.intValue());
+        Double big1 = new Double(first);
+        Double big2 = new Double(second);
+        return BigDecimal.valueOf(Math.pow(big1, big2));
     }
 
 

diff --git a/src/test/java/com/github/bgora/rpnlibrary/AdvancedCalulatorTest.java b/src/test/java/com/github/bgora/rpnlibrary/AdvancedCalulatorTest.java
@@ -48,7 +48,7 @@ public void testCalculate() throws RPNException {
     @Test
     public void testMultiply() throws RPNException {
         BigDecimal result = calc.calculate("2*8");
-        assertEquals("2*8", BigDecimal.valueOf(16), result);
+        assertEquals("2*8", BigDecimal.valueOf(16), result.setScale(0, RoundingMode.HALF_EVEN));
     }
 
     @Test
@@ -67,14 +67,14 @@ public void testMultiplyDouble3AfterDot() throws RPNException {
     @Test
     public void testPower() throws RPNException {
         BigDecimal result = calc.calculate("2^8");
-        assertEquals("2^8", BigDecimal.valueOf(256), result);
+        assertEquals("2^8", BigDecimal.valueOf(256), result.setScale(0, RoundingMode.HALF_EVEN));
     }
 
 
     @Test
     public void testPowerDouble() throws RPNException {
         BigDecimal result = calc.calculate("3.678^2");
-        assertEquals("3.678^2", new BigDecimal("13.527684"), result);
+        assertEquals("3.678^2", new BigDecimal("13.527684"), result.setScale(6, RoundingMode.HALF_EVEN));
     }
 
     @Test
@@ -98,13 +98,13 @@ public void testDiv() throws RPNException {
     @Test
     public void testDivDouble() throws RPNException {
         BigDecimal result = calc.calculate("10.55/4");
-        assertEquals("10.55/4", BigDecimal.valueOf(2.64), result);
+        assertEquals("10.55/4", BigDecimal.valueOf(2.64), result.setScale(2, RoundingMode.HALF_EVEN));
     }
 
     @Test
     public void testDivDouble3AfterDot() throws RPNException {
         BigDecimal result = calc.calculate("10.505/4");
-        assertEquals("10.505/4", BigDecimal.valueOf(2.626), result);
+        assertEquals("10.505/4", BigDecimal.valueOf(2.626), result.setScale(3, BigDecimal.ROUND_HALF_EVEN));
     }
 
     @Test
@@ -165,4 +165,22 @@ public void testAddTousands() throws RPNException {
     public void shouldThrowRPNException() throws RPNException {
         calc.calculate("aaaaa");
     }
+
+    @Test
+    public void shouldReturn2andHalf() throws RPNException {
+        BigDecimal result =  calc.calculate("5/2");
+        assertEquals(BigDecimal.valueOf(2.5).setScale(1), result.setScale(1));
+    }
+
+    @Test
+    public void shouldReturn35() throws RPNException {
+        BigDecimal result =  calc.calculate("7/2");
+        assertEquals(BigDecimal.valueOf(3.5).setScale(1), result.setScale(1));
+    }
+
+    @Test
+    public void shouldReturn() throws RPNException {
+        BigDecimal result =  calc.calculate("7/2");
+        assertEquals(BigDecimal.valueOf(3.5).setScale(1), result.setScale(1));
+    }
 }
diff --git a/src/test/java/com/github/bgora/rpnlibrary/AdvancedCalulatorTest2ParamFunction.java b/src/test/java/com/github/bgora/rpnlibrary/AdvancedCalulatorTest2ParamFunction.java
@@ -26,6 +26,7 @@
 import org.junit.Test;
 
 import java.math.BigDecimal;
+import java.math.RoundingMode;
 
 import static org.junit.Assert.assertEquals;
 
@@ -75,4 +76,18 @@ public void testMinMinus5() throws WrongArgumentException, NoSuchFunctionFound {
         BigDecimal result = calc.calculate("min(10, 8) -5");
         assertEquals(BigDecimal.valueOf(3), result);
     }
+
+    @Test
+    public void testMinDouble() throws WrongArgumentException, NoSuchFunctionFound {
+        BigDecimal result = calc.calculate("min(12.5, 9.4)");
+        assertEquals(BigDecimal.valueOf(9.4), result);
+    }
+
+    @Test
+    public void testMaxDouble() throws WrongArgumentException, NoSuchFunctionFound {
+        BigDecimal result = calc.calculate("max(12 345.50, 8 000.66)");
+        assertEquals(BigDecimal.valueOf(12345.50), result.setScale(1, RoundingMode.HALF_EVEN));
+    }
+
+
 }
diff --git a/src/test/java/com/github/bgora/rpnlibrary/CalculatorTest.java b/src/test/java/com/github/bgora/rpnlibrary/CalculatorTest.java
@@ -20,8 +20,8 @@
 package com.github.bgora.rpnlibrary;
 
 import com.github.bgora.rpnlibrary.exceptions.NoSuchFunctionFound;
-import com.github.bgora.rpnlibrary.exceptions.WrongArgumentException;
 import com.github.bgora.rpnlibrary.exceptions.RPNException;
+import com.github.bgora.rpnlibrary.exceptions.WrongArgumentException;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -41,14 +41,14 @@ public void setUp() throws Exception {
 
     @Test
     public void testCalculate() throws RPNException {
-        BigDecimal result = calc.calculate("2^3*(12/6)+18/3+5.0/2");
-        assertEquals("2^3*(12/6)+18/3+5.0/2", BigDecimal.valueOf(24.5), result);
+        BigDecimal result = calc.calculate("2^3*(12/6)+18/3+5/2");
+        assertEquals("2^3*(12/6)+18/3+5/2", BigDecimal.valueOf(24.5), result.setScale(1,RoundingMode.HALF_EVEN));
     }
 
     @Test
     public void testMultiply() throws RPNException {
         BigDecimal result = calc.calculate("2*8");
-        assertEquals("2*8", BigDecimal.valueOf(16), result);
+        assertEquals("2*8", BigDecimal.valueOf(16), result.setScale(0, RoundingMode.HALF_EVEN));
     }
 
     @Test
@@ -91,20 +91,20 @@ public void testSub() throws RPNException {
 
     @Test
     public void testDiv() throws RPNException {
-        BigDecimal result = calc.calculate("10.0/4");
-        assertEquals("10.0/4", BigDecimal.valueOf(2.5), result);
+        BigDecimal result = calc.calculate("10/4");
+        assertEquals("10/4", BigDecimal.valueOf(2.5), result.setScale(1,RoundingMode.HALF_EVEN));
     }
 
     @Test
     public void testDivDouble() throws RPNException {
         BigDecimal result = calc.calculate("10.55/4");
-        assertEquals("10.55/4", BigDecimal.valueOf(2.64), result);
+        assertEquals("10.55/4", BigDecimal.valueOf(2.64), result.setScale(2, RoundingMode.HALF_EVEN));
     }
 
     @Test
     public void testDivDouble3AfterDot() throws RPNException {
         BigDecimal result = calc.calculate("10.505/4");
-        assertEquals("10.505/4", BigDecimal.valueOf(2.626), result);
+        assertEquals("10.505/4", BigDecimal.valueOf(2.626), result.setScale(3, BigDecimal.ROUND_HALF_EVEN));
     }
 
     @Test
@@ -169,6 +169,6 @@ public void shouldThrowRPNException() throws RPNException {
     @Test
     public void testBrackets() throws WrongArgumentException, NoSuchFunctionFound {
         BigDecimal result = calc.calculate("10 * (5+2)");
-        assertEquals(BigDecimal.valueOf(70), result);
+        assertEquals(BigDecimal.valueOf(70), result.setScale(0, RoundingMode.HALF_EVEN));
     }
 }
diff --git a/src/test/java/com/github/bgora/rpnlibrary/CalculatorTestWithCustmoCheckers.java b/src/test/java/com/github/bgora/rpnlibrary/CalculatorTestWithCustmoCheckers.java
@@ -34,7 +34,7 @@ public class CalculatorTestWithCustmoCheckers {
 
     @Before
     public void setUp() throws Exception {
-        calc = Calculator.createCalculator(RoundingMode.HALF_UP, new DefaultChecker(), new DefaultExecutioner());
+        calc = Calculator.createCalculator(RoundingMode.HALF_EVEN, new DefaultChecker(), new DefaultExecutioner());
     }
 
     @Test
@@ -46,7 +46,7 @@ public void testCalculate() throws RPNException {
     @Test
     public void testMultiply() throws RPNException {
         BigDecimal result = calc.calculate("2*8");
-        assertEquals("2*8", BigDecimal.valueOf(16), result);
+        assertEquals("2*8", BigDecimal.valueOf(16), result.setScale(0, RoundingMode.HALF_EVEN));
     }
 
     @Test
@@ -96,13 +96,13 @@ public void testDiv() throws RPNException {
     @Test
     public void testDivDouble() throws RPNException {
         BigDecimal result = calc.calculate("10.55/4");
-        assertEquals("10.55/4", BigDecimal.valueOf(2.64), result);
+        assertEquals("10.55/4", BigDecimal.valueOf(2.64), result.setScale(2, RoundingMode.HALF_EVEN));
     }
 
     @Test
     public void testDivDouble3AfterDot() throws RPNException {
         BigDecimal result = calc.calculate("10.505/4");
-        assertEquals("10.505/4", BigDecimal.valueOf(2.626), result);
+        assertEquals("10.505/4", BigDecimal.valueOf(2.626), result.setScale(3, RoundingMode.HALF_EVEN));
     }
 
     @Test