[FIX] evaluation: fix floating point precision

Steps to reproduce

=0.1+0.1+0.1=0.3
=> FALSE but it should be TRUE

This is of course the well known issue of floating point precision.

Excel is rounding up to 1e-15 (for basic operators at least)

=0.3+1E-16=0.3 => TRUE
=0.3+1E-15=0.3 => FALSE

There are some places where Excel gets it wrong (=DELTA(0.3,0.1+0.1+0.1))

We'll never get rid of floating point precision issues, unless we use
a decimal representation instead of binary.
Using decimals is unrealistic: huge impact on the codebase, performance.
Excel doesn't do it, accounting doesn't do it. We shouldn't do it either.

Let's fix the basic arithmetic operators eq, lt, lte, gt and gte.

closes #6391

Task: 4766910
Signed-off-by: Pierre Rousseau (pro) <pro@odoo.com>
Signed-off-by: Lucas Lefèvre (lul) <lul@odoo.com>

Author: LucasLefevre

src/functions/module_operators.ts

@@ -83,6 +83,10 @@ function isEmpty(data: Maybe<FunctionResultObject>): boolean {
 
 const getNeutral = { number: 0, string: "", boolean: false };
 
+function areAlmostEqual(value1: number, value2: number, epsilon: number = 2e-16): boolean {
+  return Math.abs(value1 - value2) < epsilon;
+}
+
 export const EQ = {
   description: _t("Equal."),
   args: [
@@ -107,6 +111,9 @@ export const EQ = {
     if (isEvaluationError(_value2)) {
       throw value2;
     }
+    if (typeof _value1 === "number" && typeof _value2 === "number") {
+      return areAlmostEqual(_value1, _value2);
+    }
     return _value1 === _value2;
   },
 } satisfies AddFunctionDescription;
@@ -155,6 +162,9 @@ export const GT = {
     value2: Maybe<FunctionResultObject>
   ): boolean {
     return applyRelationalOperator(value1, value2, (v1, v2) => {
+      if (typeof v1 === "number" && typeof v2 === "number") {
+        return !areAlmostEqual(v1, v2) && v1 > v2;
+      }
       return v1 > v2;
     });
   },
@@ -174,6 +184,9 @@ export const GTE = {
     value2: Maybe<FunctionResultObject>
   ): boolean {
     return applyRelationalOperator(value1, value2, (v1, v2) => {
+      if (typeof v1 === "number" && typeof v2 === "number") {
+        return areAlmostEqual(v1, v2) || v1 > v2;
+      }
       return v1 >= v2;
     });
   },

tests/functions/module_operators.test.ts

@@ -147,6 +147,12 @@ describe("EQ formula", () => {
     expect(evaluateCell("A1", { A1: "=EQ(FALSE, )" })).toBe(true);
   });
 
+  test("floating point rounding", () => {
+    expect(evaluateCell("A1", { A1: "=EQ(0.3, 0.1+0.1+0.1)" })).toBe(true);
+    expect(evaluateCell("A1", { A1: "=EQ(0.3, 0.3+1e-16)" })).toBe(true);
+    expect(evaluateCell("A1", { A1: "=EQ(0.3, 0.3+1e-15)" })).toBe(false);
+  });
+
   test("functional tests on cell arguments", () => {
     expect(evaluateCell("A1", { A1: "=EQ(A2, A3)" })).toBe(true);
     expect(evaluateCell("A1", { A1: "=EQ(A2, A3)", A3: "0" })).toBe(true);
@@ -252,6 +258,13 @@ describe("GT formula", () => {
     expect(evaluateCell("A1", { A1: "=GT(A2, A3)", A2: '="1"', A3: "99999" })).toBe(true);
     expect(evaluateCell("A1", { A1: "=GT(A2, A3)", A2: '="1"', A3: '="99999"' })).toBe(false);
   });
+
+  test("floating point rounding", () => {
+    expect(evaluateCell("A1", { A1: "=GT(0.3, 0.1+0.1+0.1)" })).toBe(false);
+    expect(evaluateCell("A1", { A1: "=GT(0.3, 0.3+1e-16)" })).toBe(false);
+    expect(evaluateCell("A1", { A1: "=GT(0.3, 0.3-1e-16)" })).toBe(false);
+    expect(evaluateCell("A1", { A1: "=GT(0.3, 0.3-1e-15)" })).toBe(true);
+  });
 });
 
 describe("GTE formula", () => {
@@ -304,6 +317,14 @@ describe("GTE formula", () => {
     expect(evaluateCell("A1", { A1: '=GTE("1", "99999")' })).toBe(false);
   });
 
+  test("floating point rounding", () => {
+    expect(evaluateCell("A1", { A1: "=GTE(0.3, 0.1+0.1+0.1)" })).toBe(true);
+    expect(evaluateCell("A1", { A1: "=GTE(0.3, 0.3+1e-16)" })).toBe(true);
+    expect(evaluateCell("A1", { A1: "=GTE(0.3, 0.3-1e-16)" })).toBe(true);
+    expect(evaluateCell("A1", { A1: "=GTE(0.3, 0.3-1e-15)" })).toBe(true);
+    expect(evaluateCell("A1", { A1: "=GTE(0.3, 0.3+1e-15)" })).toBe(false);
+  });
+
   test("functional tests on cell arguments", () => {
     expect(evaluateCell("A1", { A1: "=GTE(A2, A3)" })).toBe(true);
     expect(evaluateCell("A1", { A1: "=GTE(A2, A3)", A2: "1" })).toBe(true);
@@ -431,6 +452,13 @@ describe("LT formula", () => {
     expect(evaluateCell("A1", { A1: "=LT(A2, 42)", A2: "=KABOUM" })).toBe("#BAD_EXPR");
     expect(evaluateCell("A1", { A1: "=LT(KABOUM, KABOUM)" })).toBe("#BAD_EXPR");
   });
+
+  test("floating point rounding", () => {
+    expect(evaluateCell("A1", { A1: "=LT(0.3, 0.1+0.1+0.1)" })).toBe(false);
+    expect(evaluateCell("A1", { A1: "=LT(0.3, 0.3+1e-16)" })).toBe(false);
+    expect(evaluateCell("A1", { A1: "=LT(0.3, 0.3-1e-16)" })).toBe(false);
+    expect(evaluateCell("A1", { A1: "=LT(0.3, 0.3+1e-15)" })).toBe(true);
+  });
 });
 
 describe("LTE formula", () => {
@@ -483,6 +511,10 @@ describe("LTE formula", () => {
     expect(evaluateCell("A1", { A1: '=LTE("1", "99999")' })).toBe(true);
   });
 
+  test("floating point rounding", () => {
+    expect(evaluateCell("A1", { A1: "=LTE(0.3, 0.1+0.1+0.1)" })).toBe(true);
+  });
+
   test("functional tests on cell arguments", () => {
     expect(evaluateCell("A1", { A1: "=LTE(A2, A3)" })).toBe(true);
     expect(evaluateCell("A1", { A1: "=LTE(A2, A3)", A2: "1" })).toBe(false);
@@ -521,6 +553,14 @@ describe("LTE formula", () => {
     expect(evaluateCell("A1", { A1: "=LTE(A2, 42)", A2: "=KABOUM" })).toBe("#BAD_EXPR");
     expect(evaluateCell("A1", { A1: "=LTE(KABOUM, KABOUM)" })).toBe("#BAD_EXPR");
   });
+
+  test("floating point rounding", () => {
+    expect(evaluateCell("A1", { A1: "=LTE(0.3, 0.1+0.1+0.1)" })).toBe(true);
+    expect(evaluateCell("A1", { A1: "=LTE(0.3, 0.3+1e-16)" })).toBe(true);
+    expect(evaluateCell("A1", { A1: "=LTE(0.3, 0.3-1e-16)" })).toBe(true);
+    expect(evaluateCell("A1", { A1: "=LTE(0.3, 0.3-1e-15)" })).toBe(false);
+    expect(evaluateCell("A1", { A1: "=LTE(0.3, 0.3+1e-15)" })).toBe(true);
+  });
 });
 
 describe("MINUS formula", () => {
@@ -656,6 +696,12 @@ describe("NE formula", () => {
     expect(evaluateCell("A1", { A1: "=NE(A2, 42)", A2: "=KABOUM" })).toBe("#BAD_EXPR");
     expect(evaluateCell("A1", { A1: "=NE(KABOUM, KABOUM)" })).toBe("#BAD_EXPR");
   });
+
+  test("floating point rounding", () => {
+    expect(evaluateCell("A1", { A1: "=NE(0.3, 0.1+0.1+0.1)" })).toBe(false);
+    expect(evaluateCell("A1", { A1: "=NE(0.3, 0.3+1e-16)" })).toBe(false);
+    expect(evaluateCell("A1", { A1: "=NE(0.3, 0.3+1e-15)" })).toBe(true);
+  });
 });
 
 describe("POW formula", () => {