Fix - Internal lib - Fix issues with calcLinearProgression method

Author: graphieros

src/lib.js

@@ -843,56 +843,39 @@ export function convertConfigColors(config, seen = new WeakSet()) {
 }
 
 export function calcLinearProgression(plots) {
-    let x1, y1, x2, y2;
-    const len = plots.length;
-
-    if (!plots || plots.length === 0) {
-        return {
-            x1: 0,
-            y1: 0,
-            x2: 0,
-            y2: 0,
-            slope: 0,
-            trend: 0
-        }
-    }
-
-    let sumX = 0;
-    let sumY = 0;
-    let sumXY = 0;
-    let sumXX = 0;
-    for (const { x, y } of plots) {
-        sumX += x;
-        sumY += y;
-        sumXY += x * y;
-        sumXX += x * x;
-    }
-    const slope = (len * sumXY - sumX * sumY) / (len * sumXX - sumX * sumX);
-    const intercept = (sumY - slope * sumX) / len;
-    x1 = plots[0].x;
-    x2 = plots[len - 1].x;
-    y1 = slope * x1 + intercept;
-    y2 = slope * x2 + intercept;
-
-    const trend = calcPercentageTrend(plots.map(p => p.value));
-
-    return { x1, y1, x2, y2, slope, trend };
-}
-
-export function calcPercentageTrend(arr) {
-    const initialNumber = arr[0];
-    const lastNumber = arr[arr.length - 1];
-    const overallChange = lastNumber - initialNumber;
-
-    let totalMagnitude = 0;
-
-    for (let i = 1; i < arr.length; i++) {
-        const difference = Math.abs(arr[i] - arr[i - 1]);
-        totalMagnitude += difference;
-    }
-
-    const percentageTrend = (overallChange / totalMagnitude);
-    return isNaN(percentageTrend) ? 0 : percentageTrend;
+    const len = plots?.length ?? 0;
+    if (len < 2) return { x1: 0, y1: 0, x2: 0, y2: 0, slope: 0, trend: 0 };
+
+    let sx = 0, sy = 0, sxy = 0, sxx = 0;
+    for (const { x, y } of plots) { sx += x; sy += y; sxy += x * y; sxx += x * x; }
+    const denomPx = len * sxx - sx * sx || 1;
+    const slopePx = (len * sxy - sx * sy) / denomPx;
+    const interceptPx = (sy - slopePx * sx) / len;
+
+    const x1 = plots[0].x;
+    const x2 = plots[len - 1].x;
+    const y1 = slopePx * x1 + interceptPx;
+    const y2 = slopePx * x2 + interceptPx;
+
+    let vx = 0, vy = 0, vxy = 0, vxx = 0;
+    for (let i = 0; i < len; i += 1) { 
+        vx += i; 
+        vy += plots[i].value; 
+        vxy += i * plots[i].value; 
+        vxx += i * i; 
+    }
+    const denomV = len * vxx - vx * vx || 1;
+    const slopeV = (len * vxy - vx * vy) / denomV;
+    const interceptV = (vy - slopeV * vx) / len;
+
+    const vStart = interceptV;
+    const vEnd   = slopeV * (len - 1) + interceptV;
+
+    const EPS = 1e-9;
+    const scale = Math.max(Math.abs(vStart), Math.abs(vy / len), Math.abs(vEnd), EPS);
+    const trend = (vEnd - vStart) / scale;
+
+    return { x1, y1, x2, y2, slope: slopePx, trend };
 }
 
 export function calcMedian(arr) {

tests/lib.test.js

@@ -17,7 +17,6 @@ import {
     buildInterLineAreas,
     calcLinearProgression,
     calcMedian,
-    calcPercentageTrend,
     calcPolygonPoints,
     calcStarPoints,
     calcTrend,
@@ -783,42 +782,48 @@ describe("createSmoothPath", () => {
     });
 });
 
-describe("calcPercentageTrend", () => {
-    test("returns a growth trend from an array of numbers", () => {
-        const arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        expect(calcPercentageTrend(arr)).toBe(1);
-
-        const arr2 = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0];
-        expect(calcPercentageTrend(arr2)).toBe(-1);
+describe("calcLinearProgression", () => {
+    test("creates a linear progression object from an array of coordinates", () => {
+        const d1 = [
+            { x: 1, y: 1, value: 1 },
+            { x: 2, y: 2, value: 2 },
+        ];
+        expect(calcLinearProgression(d1)).toStrictEqual({
+            x1: 1,
+            y1: 1,
+            x2: 2,
+            y2: 2,
+            slope: 1,
+            trend: 0.5,
+        });
 
-        const arr3 = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
-        expect(calcPercentageTrend(arr3)).toBe(0);
+        const d2 = [
+            { x: 1, y: 1, value: 1 },
+            { x: 2, y: 0, value: 0 },
+        ];
 
-        const arr4 = [1, 2, 1.5, 1.25, 1.125, 1.065];
-        expect(calcPercentageTrend(arr4)).toBe(0.033591731266149845);
-    });
-});
+        expect(calcLinearProgression(d2)).toStrictEqual({
+            x1: 1,
+            y1: 1,
+            x2: 2,
+            y2: 0,
+            slope: -1,
+            trend: -1,
+        });
 
-describe("calcLinearProgression", () => {
-    test("creates a linear progression object from an array of coordinates", () => {
-        const plots = [
+        const d3 = [
             { x: 1, y: 1, value: 1 },
-            { x: 2, y: 1.1, value: 1.1 },
-            { x: 3, y: 1.3, value: 1.3 },
-            { x: 4, y: 1.6, value: 1.6 },
-            { x: 5, y: 2, value: 2 },
-            { x: 6, y: 2.5, value: 2.5 },
-            { x: 7, y: 3.1, value: 3.1 },
-            { x: 8, y: 3.8, value: 3.8 },
-            { x: 9, y: 2.6, value: 2.6 },
+            { x: 2, y: 0, value: 0 },
+            { x: 3, y: 1, value: 1 },
         ];
-        expect(calcLinearProgression(plots)).toStrictEqual({
+
+        expect(calcLinearProgression(d3)).toStrictEqual({
             x1: 1,
-            y1: 0.8444444444444444,
-            x2: 9,
-            y2: 3.3777777777777773,
-            slope: 0.31666666666666665,
-            trend: 0.4000000000000001,
+            y1: 0.6666666666666666,
+            x2: 3,
+            y2: 0.6666666666666666,
+            slope: 0,
+            trend: 0,
         });
     });
 });