Fixes issue 2043-Round function precision (#2044)

Author: JanKallman

src/EPPlus/FormulaParsing/Excel/Functions/MathFunctions/Round.cs

@@ -42,7 +42,9 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing
             {
                 return CreateResult(System.Math.Round(number / System.Math.Pow(10, positivDigits), 0, MidpointRounding.AwayFromZero) * System.Math.Pow(10, positivDigits), DataType.Integer);
             }
-            return CreateResult(System.Math.Round(number, nDigits, MidpointRounding.AwayFromZero), DataType.Decimal);
+            //We cast to decimal here to avoid issues where the double is rounded incorrectly due to floating-point problems
+            //. For example 39.285 is incorrectly rounded down  
+            return CreateResult((double)System.Math.Round((decimal)number, nDigits, MidpointRounding.AwayFromZero), DataType.Decimal);
         }
         public override int ArgumentMinLength => 2;
     }

src/EPPlus/FormulaParsing/Excel/Functions/MathFunctions/Rounddown.cs

@@ -31,7 +31,7 @@ internal class Rounddown : ExcelFunction
         public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)
         {
             if (arguments[0].Value == null) return CreateResult(0d, DataType.Decimal);
-            var number = ArgToDecimal(arguments, 0, out ExcelErrorValue e1, context.Configuration.PrecisionAndRoundingStrategy);
+            var number = (decimal)ArgToDecimal(arguments, 0, out ExcelErrorValue e1, context.Configuration.PrecisionAndRoundingStrategy);
             if (e1 != null) return CompileResult.GetErrorResult(e1.Type);
 
             var nDecimals = ArgToInt(arguments, 1, out ExcelErrorValue e2);
@@ -50,12 +50,12 @@ public override CompileResult Execute(IList<FunctionArgument> arguments, Parsing
                 result = (long)Math.Floor(number);
                 result = result - (result % System.Math.Pow(10, (nDecimals*-1)));
             }
-            return CreateResult(result * nFactor, DataType.Decimal);
+            return CreateResult((double)result * nFactor, DataType.Decimal);
         }
 
-        private static double RoundDownDecimalNumber(double number, int nDecimals)
+        private static double RoundDownDecimalNumber(decimal number, int nDecimals)
         {
-            long integerRepresentation = (long)Math.Floor(number * Math.Pow(10d, nDecimals));
+            long integerRepresentation = (long)Math.Floor(number * (decimal)Math.Pow(10d, nDecimals));
             var result = integerRepresentation / Math.Pow(10d, nDecimals);
             return result;
         }

src/EPPlus/FormulaParsing/Excel/Functions/MathFunctions/Roundup.cs

@@ -32,13 +32,13 @@ internal class Roundup : ExcelFunction
         public override CompileResult Execute(IList<FunctionArgument> arguments, ParsingContext context)
         {
             if (arguments[0].Value == null) return CreateResult(0d, DataType.Decimal);
-            var number = ArgToDecimal(arguments, 0, out ExcelErrorValue e1, context.Configuration.PrecisionAndRoundingStrategy);
+            var number = (decimal)ArgToDecimal(arguments, 0, out ExcelErrorValue e1, context.Configuration.PrecisionAndRoundingStrategy);
             if (e1 != null) return CompileResult.GetErrorResult(e1.Type);
             var nDigits = ArgToInt(arguments, 1, out ExcelErrorValue e2);
             if (e2 != null) return CompileResult.GetErrorResult(e2.Type);
-            double result = (number >= 0) 
-                ? System.Math.Ceiling(number * System.Math.Pow(10, nDigits)) / System.Math.Pow(10, nDigits)
-                : System.Math.Floor(number * System.Math.Pow(10, nDigits)) / System.Math.Pow(10, nDigits);
+            double result = (double)((number >= 0) 
+                ? System.Math.Ceiling(number * (decimal)Math.Pow(10, nDigits)) / (decimal)Math.Pow(10, nDigits)
+                : System.Math.Floor(number * (decimal)Math.Pow(10, nDigits)) / (decimal)Math.Pow(10, nDigits));
             return CreateResult(result, DataType.Decimal);
         }
     }

src/EPPlusTest/FormulaParsing/Excel/Functions/MathFunctions/RoundTests.cs

@@ -211,7 +211,7 @@ public void RoundShouldUseFifteenSignificantFigures()
                 sheet.Calculate(opt => opt.PrecisionAndRoundingStrategy = PrecisionAndRoundingStrategy.Excel);
                 Assert.AreEqual(120253.88, sheet.Cells["A2"].Value);
                 sheet.Calculate(opt => opt.PrecisionAndRoundingStrategy = PrecisionAndRoundingStrategy.DotNet);
-                Assert.AreEqual(120253.87, sheet.Cells["A2"].Value);
+                Assert.AreEqual(120253.88, sheet.Cells["A2"].Value); //Changed from 120253.87, 2025-06-26, when changed to type-cast the number to decimal in the ROUND function.
             }
         }
 
@@ -314,5 +314,16 @@ public void RoundDownShouldNotChangeCorrectValues()
                 Assert.AreEqual(17.38, sheet.Cells["A2"].Value);
             }
         }
+        [TestMethod]
+        public void RoundTypeCastToDecimalShouldAvoidFloatingPointError()
+        {
+            using (var package = new ExcelPackage())
+            {
+                var ws = package.Workbook.Worksheets.Add("Sheet1");
+                ws.Cells["A1"].Formula = "Round(39.285,2)";
+                ws.Calculate();
+                Assert.AreEqual(39.29, ws.Cells["A1"].Value);
+            }
+        }
     }
 }

src/EPPlusTest/Issues/FormulaCalculationIssues.cs

@@ -1152,6 +1152,19 @@ public void s875()
                 Assert.AreEqual(-1083371.20, (double)ws.Cells["P13"].Value, 0.0001);
             }
         }
+        [TestMethod]
+        public void s868()
+        {
+            using (var package = OpenTemplatePackage("s868.xlsx"))
+            {
+                var wb = package.Workbook;
+                var ws = wb.Worksheets["aliss"];
+                wb.Worksheets.Add("AlissCopy", ws);
+                ws.Cells["CW151"].Calculate();
+                Assert.AreEqual(39.29, ws.Cells["CW151"].Value);
+                SaveAndCleanup(package);
+            }
+        }
     }
 }