fix: xBoxPlot deals correctly with very close numbers

Author: lpatiny

src/x/__tests__/xBoxPlot.test.ts

@@ -144,3 +144,16 @@ test('outliers', () => {
     max: 100,
   });
 });
+
+test('close values', () => {
+  const array = [1.4029999999999998, 1.403];
+  const result = xBoxPlot(array);
+
+  expect(result).toStrictEqual({
+    min: 1.4029999999999998,
+    q1: 1.403,
+    median: 1.403,
+    q3: 1.403,
+    max: 1.403,
+  });
+});

src/x/__tests__/xBoxPlotWithOutliers.test.ts

@@ -39,3 +39,22 @@ test('outliers', () => {
     outliers: [100],
   });
 });
+
+test('close values', () => {
+  const array = [1.4029999999999998, 1.403];
+  const result = xBoxPlotWithOutliers(array);
+
+  expect(result).toStrictEqual({
+    min: 1.4029999999999998,
+    q1: 1.403,
+    median: 1.403,
+    q3: 1.403,
+    max: 1.403,
+    lowerWhisker: 1.4029999999999998,
+    upperWhisker: 1.403,
+    minWhisker: 1.4029999999999998,
+    maxWhisker: 1.403,
+    iqr: 0,
+    outliers: [],
+  });
+});

src/x/__tests__/xRobustDistributionStats.test.ts

@@ -32,6 +32,28 @@ test('one element', () => {
   });
 });
 
+test('two close elements', () => {
+  const data = [1.4029999999999998, 1.403];
+  const stats = xRobustDistributionStats(data);
+
+  expect(stats).toStrictEqual({
+    min: 1.4029999999999998,
+    q1: 1.403,
+    median: 1.403,
+    q3: 1.403,
+    max: 1.403,
+    lowerWhisker: 1.4029999999999998,
+    upperWhisker: 1.403,
+    minWhisker: 1.4029999999999998,
+    maxWhisker: 1.403,
+    iqr: 0,
+    outliers: [],
+    mean: 1.403,
+    nb: 2,
+    sd: 0,
+  });
+});
+
 test('4 elements', () => {
   const data = [15, 13, 17, 7];
   const stats = xRobustDistributionStats(data);

src/x/xBoxPlot.ts

@@ -32,12 +32,28 @@ export function xBoxPlot(array: NumberArray): XBoxPlot {
   // and sort typed array that is much faster than sorting a normal array
   array = Float64Array.from(array).sort();
 
+  // need to deal with very close points otherwise it yields to incorrect results
+  if ((array.at(-1) as number) - array[0] <= Number.EPSILON) {
+    // if one of the 2 numbers is an integer let's take this one
+    const shortTestNumber =
+      String(array[0]).length < String(array.at(-1)).length
+        ? array[0]
+        : (array.at(-1) as number);
+    return {
+      min: array[0],
+      q1: shortTestNumber,
+      median: shortTestNumber,
+      q3: shortTestNumber,
+      max: array.at(-1) as number,
+    };
+  }
   const posQ1 = (array.length - 1) / 4;
   const posQ3 = (array.length - 1) * (3 / 4);
   const medianPos = (array.length - 1) / 2;
 
   const q1MinProportion = posQ1 % 1;
   const q3MinProportion = posQ3 % 1;
+
   const medianMinProportion = medianPos % 1;
   return {
     min: array[0],

src/x/xBoxPlotWithOutliers.ts

@@ -58,6 +58,18 @@ export interface XBoxPlotWithOutliers {
 export function xBoxPlotWithOutliers(array: NumberArray): XBoxPlotWithOutliers {
   const boxPlot = xBoxPlot(array);
 
+  if (boxPlot.max - boxPlot.min <= Number.EPSILON) {
+    return {
+      ...boxPlot,
+      lowerWhisker: boxPlot.min,
+      upperWhisker: boxPlot.max,
+      minWhisker: boxPlot.min,
+      maxWhisker: boxPlot.max,
+      iqr: 0,
+      outliers: [],
+    };
+  }
+
   const iqr = boxPlot.q3 - boxPlot.q1;
   const lowerWhisker = boxPlot.q1 - 1.5 * iqr;
   const upperWhisker = boxPlot.q3 + 1.5 * iqr;

src/x/xRobustDistributionStats.ts

@@ -26,6 +26,16 @@ export function xRobustDistributionStats(
 ): XRobustDistributionStats {
   const boxPlot = xBoxPlotWithOutliers(array);
   let filteredArray: NumberArray;
+
+  if (boxPlot.max - boxPlot.min <= Number.EPSILON) {
+    return {
+      ...boxPlot,
+      mean: boxPlot.median,
+      sd: array.length === 1 ? Number.NaN : 0,
+      nb: array.length,
+    };
+  }
+
   if (boxPlot.outliers.length === 0) {
     filteredArray = array;
   } else {