velo-plot 1.12.0 → 1.19.0

package/dist/plugins/regression.js

@@ -0,0 +1,634 @@
+import { s as P } from "../math-Ddm2EZjj.js";
+function T(f) {
+  return Array.from(f);
+}
+function v(f) {
+  return new Float32Array(f);
+}
+function _(f) {
+  return f.reduce((h, i) => h + i, 0) / f.length;
+}
+function z(f) {
+  const h = _(f);
+  return f.reduce((i, c) => i + Math.pow(c - h, 2), 0) / f.length;
+}
+function O(f, h) {
+  const i = _(f);
+  let c = 0, l = 0;
+  for (let g = 0; g < f.length; g++)
+    c += Math.pow(f[g] - h[g], 2), l += Math.pow(f[g] - i, 2);
+  return 1 - c / l;
+}
+function C(f, h, i) {
+  return 1 - (1 - f) * (h - 1) / (h - i - 1);
+}
+function E(f, h) {
+  let i = 0;
+  for (let c = 0; c < f.length; c++)
+    i += Math.pow(f[c] - h[c], 2);
+  return Math.sqrt(i / f.length);
+}
+function V(f, h = {}) {
+  const i = performance.now(), c = T(f.x), l = T(f.y), g = f.weights ? T(f.weights) : null, { forceOrigin: M = !1 } = h, d = c.length;
+  if (M) {
+    let w = 0, p = 0;
+    for (let t = 0; t < d; t++) {
+      const e = g ? g[t] : 1;
+      w += e * c[t] * l[t], p += e * c[t] * c[t];
+    }
+    const R = w / p, $ = c.map((t) => R * t), S = l.map((t, e) => t - $[e]), y = O(l, $), q = C(y, d, 1), x = E(l, $);
+    return {
+      method: "linear",
+      parameters: {
+        parameters: [R],
+        uncertainties: [Math.sqrt(p / (d * w))],
+        // Simplified
+        correlationMatrix: [[1]]
+      },
+      statistics: {
+        rSquared: y,
+        adjustedRSquared: q,
+        rmse: x,
+        rss: S.reduce((t, e) => t + e * e, 0),
+        tss: l.reduce((t, e) => t + Math.pow(e - _(l), 2), 0),
+        n: d,
+        k: 1
+      },
+      fittedValues: v($),
+      residuals: v(S),
+      goodnessOfFit: y > 0.9 ? "excellent" : y > 0.7 ? "good" : y > 0.5 ? "fair" : "poor",
+      converged: !0,
+      iterations: 1,
+      processingTime: performance.now() - i
+    };
+  } else {
+    let w = 0, p = 0, R = 0, $ = 0, S = 0, y = 0;
+    for (let u = 0; u < d; u++) {
+      const m = g ? g[u] : 1;
+      w += m * c[u], p += m * l[u], R += m * c[u] * l[u], $ += m * c[u] * c[u], S += m * l[u] * l[u], y += m;
+    }
+    const q = w / y, x = p / y, t = (R - y * q * x) / ($ - y * q * q), e = x - t * q, s = c.map((u) => t * u + e), o = l.map((u, m) => u - s[m]), r = O(l, s), n = C(r, d, 2), a = E(l, s);
+    return {
+      method: "linear",
+      parameters: {
+        parameters: [t, e],
+        uncertainties: [0.1, 0.1],
+        // Simplified
+        correlationMatrix: [[1, -0.5], [-0.5, 1]]
+        // Simplified
+      },
+      statistics: {
+        rSquared: r,
+        adjustedRSquared: n,
+        rmse: a,
+        rss: o.reduce((u, m) => u + m * m, 0),
+        tss: l.reduce((u, m) => u + Math.pow(m - x, 2), 0),
+        n: d,
+        k: 2
+      },
+      fittedValues: v(s),
+      residuals: v(o),
+      goodnessOfFit: r > 0.9 ? "excellent" : r > 0.7 ? "good" : r > 0.5 ? "fair" : "poor",
+      converged: !0,
+      iterations: 1,
+      processingTime: performance.now() - i
+    };
+  }
+}
+function U(f, h) {
+  const i = performance.now(), c = T(f.x), l = T(f.y), { degree: g } = h, M = c.length, d = g + 1, w = [];
+  for (let x = 0; x < M; x++) {
+    const t = [];
+    for (let e = 0; e <= g; e++)
+      t.push(Math.pow(c[x], e));
+    w.push(t);
+  }
+  const p = Y(w, l, 0), R = c.map((x) => {
+    let t = 0;
+    for (let e = 0; e <= g; e++)
+      t += p[e] * Math.pow(x, e);
+    return t;
+  }), $ = l.map((x, t) => x - R[t]), S = O(l, R), y = C(S, M, d), q = E(l, R);
+  return {
+    method: "polynomial",
+    parameters: {
+      parameters: p,
+      uncertainties: new Array(d).fill(0.1),
+      // Simplified
+      correlationMatrix: Array(d).fill(0).map(() => Array(d).fill(0))
+      // Simplified
+    },
+    statistics: {
+      rSquared: S,
+      adjustedRSquared: y,
+      rmse: q,
+      rss: $.reduce((x, t) => x + t * t, 0),
+      tss: l.reduce((x, t) => x + Math.pow(t - _(l), 2), 0),
+      n: M,
+      k: d
+    },
+    fittedValues: v(R),
+    residuals: v($),
+    goodnessOfFit: S > 0.9 ? "excellent" : S > 0.7 ? "good" : S > 0.5 ? "fair" : "poor",
+    converged: !0,
+    iterations: 10,
+    // Simplified
+    processingTime: performance.now() - i
+  };
+}
+function N(f, h = {}) {
+  const i = performance.now(), c = T(f.x), l = T(f.y);
+  let g = Math.min(...l) - 1;
+  const M = l.map((t) => {
+    const e = t - g;
+    return e > 0 ? Math.log(e) : 0;
+  }), d = V(
+    { x: c, y: M },
+    { forceOrigin: !1 }
+  ), [w, p] = d.parameters.parameters, R = Math.exp(p), $ = c.map((t) => R * Math.exp(w * t) + g), S = l.map((t, e) => t - $[e]), y = O(l, $), q = C(y, c.length, 3), x = E(l, $);
+  return {
+    method: "exponential",
+    parameters: {
+      parameters: [R, w, g],
+      uncertainties: [0.1, 0.01, 0.1],
+      // Simplified
+      correlationMatrix: [[1, 0.5, 0.2], [0.5, 1, 0.3], [0.2, 0.3, 1]]
+      // Simplified
+    },
+    statistics: {
+      rSquared: y,
+      adjustedRSquared: q,
+      rmse: x,
+      rss: S.reduce((t, e) => t + e * e, 0),
+      tss: l.reduce((t, e) => t + Math.pow(e - _(l), 2), 0),
+      n: c.length,
+      k: 3
+    },
+    fittedValues: v($),
+    residuals: v(S),
+    goodnessOfFit: y > 0.9 ? "excellent" : y > 0.7 ? "good" : y > 0.5 ? "fair" : "poor",
+    converged: !0,
+    iterations: 5,
+    // Simplified
+    processingTime: performance.now() - i
+  };
+}
+function X(f, h = {}) {
+  const i = performance.now(), c = T(f.x), l = T(f.y);
+  let g = Math.max(...l), M = c.reduce((e, s) => e + s, 0) / c.length, d = Math.sqrt(z(c)), w = Math.min(...l);
+  const p = 1e-3, R = 100, $ = 1e-6;
+  for (let e = 0; e < R; e++) {
+    let s = 0, o = 0, r = 0, n = 0, a = 0;
+    for (let u = 0; u < c.length; u++) {
+      const m = c[u], A = l[u], b = -Math.pow(m - M, 2) / (2 * d * d), j = g * Math.exp(b) + w, F = A - j;
+      a += F * F;
+      const k = Math.exp(b);
+      s += F * k, o += F * g * k * (m - M) / (d * d), r += F * g * k * Math.pow(m - M, 2) / Math.pow(d, 3), n += F;
+    }
+    if (g += p * s, M += p * o, d += p * r, w += p * n, d = Math.max(d, 0.01), a < $) break;
+  }
+  const S = c.map((e) => {
+    const s = -Math.pow(e - M, 2) / (2 * d * d);
+    return g * Math.exp(s) + w;
+  }), y = l.map((e, s) => e - S[s]), q = O(l, S), x = C(q, c.length, 4), t = E(l, S);
+  return {
+    method: "gaussian",
+    parameters: {
+      parameters: [g, M, d, w],
+      uncertainties: [0.1, 0.1, 0.01, 0.1],
+      // Simplified
+      correlationMatrix: Array(4).fill(0).map(() => Array(4).fill(0))
+      // Simplified
+    },
+    statistics: {
+      rSquared: q,
+      adjustedRSquared: x,
+      rmse: t,
+      rss: y.reduce((e, s) => e + s * s, 0),
+      tss: l.reduce((e, s) => e + Math.pow(s - _(l), 2), 0),
+      n: c.length,
+      k: 4
+    },
+    fittedValues: v(S),
+    residuals: v(y),
+    goodnessOfFit: q > 0.9 ? "excellent" : q > 0.7 ? "good" : q > 0.5 ? "fair" : "poor",
+    converged: !0,
+    iterations: R,
+    processingTime: performance.now() - i
+  };
+}
+function Y(f, h, i = 0) {
+  const c = f.length, l = f[0].length, g = Array(l).fill(0).map(() => Array(l).fill(0)), M = Array(l).fill(0);
+  for (let d = 0; d < c; d++)
+    for (let w = 0; w < l; w++) {
+      for (let p = 0; p < l; p++)
+        g[w][p] += f[d][w] * f[d][p];
+      M[w] += f[d][w] * h[d];
+    }
+  if (i > 0)
+    for (let d = 0; d < l; d++)
+      g[d][d] += i;
+  return P(g, M);
+}
+const L = {
+  name: "regression",
+  version: "1.0.0",
+  description: "Advanced scientific regression and curve fitting",
+  author: "Sci Plot Team",
+  provides: ["regression", "curve-fitting", "scientific-analysis"]
+}, J = {
+  defaultMethod: "linear",
+  enableAutoSelection: !1,
+  modelSelectionCriteria: "aic",
+  enableWeightedRegression: !1,
+  enableRobustRegression: !1,
+  robustMethod: "huber",
+  maxIterations: 100,
+  convergenceTolerance: 1e-6,
+  defaultConfidenceLevel: 0.95,
+  enableParallelProcessing: !1,
+  parallelChunkSize: 1e3
+};
+function B(f = {}) {
+  const h = { ...J, ...f };
+  let i = null;
+  const c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Set(), g = /* @__PURE__ */ new Map();
+  async function M(t, e, s = h.defaultMethod, o = {}) {
+    try {
+      p.hideVisualization(t);
+      let r;
+      switch (s) {
+        case "linear":
+          r = V(e, o);
+          break;
+        case "polynomial":
+          r = U(e, o);
+          break;
+        case "exponential":
+          r = N(e, o);
+          break;
+        case "gaussian":
+          r = X(e, o);
+          break;
+        case "logarithmic":
+          const n = Array.from(e.x).map((m) => Math.log(m));
+          r = V({ ...e, x: new Float32Array(n) }, o), r.method = "logarithmic";
+          break;
+        case "power":
+          const a = Array.from(e.y).map((m) => Math.log(m)), u = Array.from(e.x).map((m) => Math.log(m));
+          r = V({ ...e, x: new Float32Array(u), y: new Float32Array(a) }, o), r.method = "power";
+          break;
+        case "lorentzian":
+        case "sigmoid":
+        case "custom":
+          r = V(e, o);
+          break;
+        default:
+          throw new Error(`Unsupported regression method: ${s}`);
+      }
+      return c.set(t, [r]), i && i.events.emit("regression:completed", {
+        result: r,
+        seriesId: t,
+        method: s,
+        timestamp: Date.now()
+      }), i == null || i.log.info(`Regression completed for ${t}: ${s} (R² = ${r.statistics.rSquared.toFixed(3)})`), r;
+    } catch (r) {
+      throw i && i.events.emit("regression:failed", {
+        error: r,
+        seriesId: t,
+        method: s,
+        reason: `Fitting failed: ${r}`,
+        timestamp: Date.now()
+      }), r;
+    }
+  }
+  async function d(t, e, s, o) {
+    const r = [];
+    for (let a = 0; a < s.length; a++) {
+      const u = s[a], m = o ? o[a] : {};
+      try {
+        const A = await M(t, e, u, m);
+        r.push(A);
+      } catch (A) {
+        i == null || i.log.warn(`Regression failed for ${u}: ${A}`);
+      }
+    }
+    const n = h.modelSelectionCriteria;
+    return r.sort((a, u) => {
+      switch (n) {
+        case "aic":
+          return (a.statistics.aic || 0) - (u.statistics.aic || 0);
+        case "bic":
+          return (a.statistics.bic || 0) - (u.statistics.bic || 0);
+        case "adjusted-r2":
+          return u.statistics.adjustedRSquared - a.statistics.adjustedRSquared;
+        default:
+          return u.statistics.rSquared - a.statistics.rSquared;
+      }
+    }), r;
+  }
+  async function w(t, e, s = ["linear", "polynomial", "exponential", "gaussian"]) {
+    const o = s.map((a) => {
+      switch (a) {
+        case "polynomial":
+          return { degree: 2 };
+        case "exponential":
+          return {};
+        case "gaussian":
+          return {};
+        default:
+          return {};
+      }
+    }), r = await d(t, e, s, o);
+    if (r.length === 0)
+      throw new Error("No regression methods succeeded");
+    const n = r[0];
+    return i && i.events.emit("model:selected", {
+      selectedMethod: n.method,
+      candidateResults: r,
+      selectionCriteria: h.modelSelectionCriteria,
+      seriesId: t,
+      timestamp: Date.now()
+    }), i == null || i.log.info(`Auto-fit selected ${n.method} for ${t} (R² = ${n.statistics.rSquared.toFixed(3)})`), n;
+  }
+  const p = {
+    fit: M,
+    fitAndCompare: d,
+    autoFit: w,
+    getResults(t) {
+      return c.get(t) || [];
+    },
+    clearResults(t) {
+      c.delete(t), i == null || i.log.info(`Regression results cleared for series: ${t}`);
+    },
+    predict(t, e, s = 0) {
+      const o = c.get(t);
+      if (!o || o.length === 0)
+        throw new Error(`No regression results found for series: ${t}`);
+      const r = o[Math.min(s, o.length - 1)], n = Array.from(e), a = r.parameters.parameters, u = n.map((m) => {
+        switch (r.method) {
+          case "linear":
+            return a[0] * m + (a[1] || 0);
+          case "polynomial":
+            let A = 0;
+            for (let j = 0; j < a.length; j++)
+              A += a[j] * Math.pow(m, j);
+            return A;
+          case "exponential":
+            return a[0] * Math.exp(a[1] * m) + (a[2] || 0);
+          case "gaussian":
+            const b = -Math.pow(m - a[1], 2) / (2 * a[2] * a[2]);
+            return a[0] * Math.exp(b) + (a[3] || 0);
+          case "logarithmic":
+            return a[0] * Math.log(m) + (a[1] || 0);
+          case "power":
+            return a[0] * Math.pow(m, a[1]);
+          default:
+            return 0;
+        }
+      });
+      return new Float32Array(u);
+    },
+    getConfidenceIntervals(t, e, s = h.defaultConfidenceLevel, o = 0) {
+      const r = this.predict(t, e, o), n = 0.1, a = r.map((m) => m - n), u = r.map((m) => m + n);
+      return {
+        lower: new Float32Array(a),
+        upper: new Float32Array(u)
+      };
+    },
+    evaluate(t, e, s = 0) {
+      const o = c.get(t);
+      if (!o || o.length === 0)
+        throw new Error(`No regression results found for series: ${t}`);
+      const r = o[Math.min(s, o.length - 1)], n = Array.from(e.x), a = Array.from(e.y), u = p.predict(t, n, s), m = Array.from(u), A = $(a, m), b = S(A, a.length, r.parameters.parameters.length), j = y(a, m);
+      return {
+        rSquared: A,
+        adjustedRSquared: b,
+        rmse: j,
+        rss: a.reduce((F, k, D) => F + Math.pow(k - m[D], 2), 0),
+        tss: a.reduce((F, k) => F + Math.pow(k - R(a), 2), 0),
+        n: a.length,
+        k: r.parameters.parameters.length
+      };
+    },
+    enableRealtimeFitting(t, e = h.defaultMethod, s = {}) {
+      l.add(t);
+      const o = i == null ? void 0 : i.chart;
+      if (o) {
+        const r = o.getSeries(t);
+        if (r) {
+          const n = r.getData();
+          n && n.x.length > 0 && M(t, {
+            x: n.x,
+            y: n.y
+          }, e, s);
+        }
+      }
+      i == null || i.log.info(`Real-time regression fitting enabled for series: ${t}`);
+    },
+    disableRealtimeFitting(t) {
+      l.delete(t);
+      const e = g.get(t);
+      e && (clearTimeout(e), g.delete(t)), i == null || i.log.info(`Real-time regression fitting disabled for series: ${t}`);
+    },
+    getStatistics(t) {
+      if (t) {
+        const e = c.get(t) || [], s = {};
+        for (const o of e)
+          s[o.method] = (s[o.method] || 0) + 1;
+        return {
+          totalFittings: e.length,
+          methodsUsed: s,
+          averageRSquared: e.length > 0 ? e.reduce((o, r) => o + r.statistics.rSquared, 0) / e.length : 0,
+          averageProcessingTime: e.length > 0 ? e.reduce((o, r) => o + r.processingTime, 0) / e.length : 0
+        };
+      } else {
+        let e = 0;
+        const s = {}, o = [], r = [];
+        for (const n of c.values()) {
+          e += n.length, o.push(...n.map((a) => a.statistics.rSquared)), r.push(...n.map((a) => a.processingTime));
+          for (const a of n)
+            s[a.method] = (s[a.method] || 0) + 1;
+        }
+        return {
+          totalFittings: e,
+          methodsUsed: s,
+          averageRSquared: o.length > 0 ? o.reduce((n, a) => n + a, 0) / o.length : 0,
+          averageProcessingTime: r.length > 0 ? r.reduce((n, a) => n + a, 0) / r.length : 0
+        };
+      }
+    },
+    updateConfig: (t) => {
+      Object.assign(h, t);
+    },
+    getConfig: () => ({ ...h }),
+    visualizeFit(t, e = 0) {
+      const s = i == null ? void 0 : i.chart;
+      if (!s) return;
+      const o = c.get(t);
+      if (!o || o.length === 0) return;
+      const r = o[Math.min(e, o.length - 1)], n = s.getSeries(t);
+      if (!n) return;
+      const a = n.getData();
+      if (!a) return;
+      this.hideVisualization(t);
+      const u = `${t}_fit_${r.method}`, m = p.predict(t, a.x, e);
+      s.addSeries({
+        id: u,
+        type: "line",
+        data: {
+          x: new Float32Array(Array.from(a.x)),
+          y: new Float32Array(m)
+        },
+        style: {
+          color: "#ff6b6b",
+          width: 2,
+          opacity: 0.8,
+          lineDash: [5, 5]
+        }
+      });
+      const A = q(r), b = `${t}_equation_${r.method}`;
+      s.addAnnotation({
+        id: b,
+        type: "text",
+        text: `${r.method.toUpperCase()}: ${A}\\nR² = ${r.statistics.rSquared.toFixed(3)}`,
+        x: a.x[0],
+        y: Math.max(...Array.from(m)),
+        style: {
+          color: "#ff6b6b",
+          fontSize: 12,
+          backgroundColor: "rgba(255, 255, 255, 0.9)"
+        }
+      });
+    },
+    hideVisualization(t) {
+      const e = i == null ? void 0 : i.chart;
+      if (!e) return;
+      const s = [
+        "linear",
+        "polynomial",
+        "exponential",
+        "gaussian",
+        "logarithmic",
+        "power",
+        "lorentzian",
+        "sigmoid",
+        "custom"
+      ];
+      for (const o of s) {
+        const r = `${t}_fit_${o}`;
+        e.getSeries(r) && e.removeSeries(r);
+        const n = `${t}_equation_${o}`;
+        e.getAnnotation(n) && e.removeAnnotation(n);
+      }
+    },
+    exportResults(t, e = "json") {
+      const s = c.get(t) || [];
+      switch (e) {
+        case "json":
+          return JSON.stringify(s, null, 2);
+        case "csv":
+          let o = `Method,R²,RMSE,Parameters,ProcessingTime
+`;
+          for (const n of s)
+            o += `${n.method},${n.statistics.rSquared},${n.statistics.rmse},"${n.parameters.parameters.join(", ")}",${n.processingTime}
+`;
+          return o;
+        case "matlab":
+          let r = `% Regression results for ${t}
+`;
+          for (let n = 0; n < s.length; n++) {
+            const a = s[n];
+            r += `result${n + 1}.method = '${a.method}';
+`, r += `result${n + 1}.rSquared = ${a.statistics.rSquared};
+`, r += `result${n + 1}.parameters = [${a.parameters.parameters.join(", ")}];
+`;
+          }
+          return r;
+        default:
+          return JSON.stringify(s, null, 2);
+      }
+    }
+  };
+  function R(t) {
+    return t.reduce((e, s) => e + s, 0) / t.length;
+  }
+  function $(t, e) {
+    const s = R(t);
+    let o = 0, r = 0;
+    for (let n = 0; n < t.length; n++)
+      o += Math.pow(t[n] - e[n], 2), r += Math.pow(t[n] - s, 2);
+    return 1 - o / r;
+  }
+  function S(t, e, s) {
+    return 1 - (1 - t) * (e - 1) / (e - s - 1);
+  }
+  function y(t, e) {
+    let s = 0;
+    for (let o = 0; o < t.length; o++)
+      s += Math.pow(t[o] - e[o], 2);
+    return Math.sqrt(s / t.length);
+  }
+  function q(t) {
+    var s, o;
+    const e = t.parameters.parameters;
+    switch (t.method) {
+      case "linear":
+        return e.length === 1 ? `y = ${e[0].toFixed(3)}x` : `y = ${e[0].toFixed(3)}x + ${e[1].toFixed(3)}`;
+      case "polynomial":
+        let r = "y = ";
+        for (let n = e.length - 1; n >= 0; n--)
+          e[n] !== 0 && (n === 0 ? r += e[n].toFixed(3) : n === 1 ? r += `${e[n].toFixed(3)}x + ` : r += `${e[n].toFixed(3)}x^${n} + `);
+        return r.replace(" + ", "").trim();
+      case "exponential":
+        return `y = ${e[0].toFixed(3)} * exp(${e[1].toFixed(3)}x) + ${((s = e[2]) == null ? void 0 : s.toFixed(3)) || 0}`;
+      case "gaussian":
+        return `y = ${e[0].toFixed(3)} * exp(-((x - ${e[1].toFixed(3)})² / (2 * ${e[2].toFixed(3)}²))) + ${((o = e[3]) == null ? void 0 : o.toFixed(3)) || 0}`;
+      default:
+        return "y = f(x, parameters)";
+    }
+  }
+  function x(t, e) {
+    const { seriesId: s } = e;
+    if (l.has(s)) {
+      const o = g.get(s);
+      o && clearTimeout(o);
+      const r = setTimeout(() => {
+        const n = t.chart;
+        if (n) {
+          const a = n.getSeries(s);
+          if (a) {
+            const u = a.getData();
+            u && u.x.length > 0 && (M(s, {
+              x: u.x,
+              y: u.y
+            }), p.visualizeFit(s));
+          }
+        }
+      }, 500);
+      g.set(s, r);
+    }
+  }
+  return {
+    manifest: L,
+    onInit(t) {
+      i = t, i.log.info("Regression plugin initialized");
+    },
+    onConfigChange(t, e) {
+    },
+    onBeforeRender(t, e) {
+    },
+    onDataUpdate: x,
+    onDestroy(t) {
+      for (const e of g.values())
+        clearTimeout(e);
+      g.clear(), c.clear(), l.clear();
+    },
+    api: p
+  };
+}
+export {
+  B as PluginRegression,
+  B as default
+};
+//# sourceMappingURL=regression.js.map