csaps-js 0.1.0 → 0.1.1

package/dist/index.global.js

@@ -87,43 +87,70 @@ var csapsjs = (function (exports) {
       }
       return lo;
     }
-    /** Evaluate component `n` at scalar `xq` with derivative order `nu`. */
-    evalScalar(n, xq, nu, extrapolate) {
-      const i = this.findPiece(xq, extrapolate);
-      if (i < 0) return NaN;
-      const s = xq - this.breaks[i];
-      const order = this.order;
-      const pieces = this.pieces;
-      const ndim = this.ndim;
-      let res = 0;
-      for (let k = 0; k < order; k++) {
-        const e = order - 1 - k;
-        if (e < nu) continue;
-        let f = 1;
-        for (let t = 0; t < nu; t++) f *= e - t;
-        const coef = this.c[(k * pieces + i) * ndim + n];
-        res += coef * f * Math.pow(s, e - nu);
-      }
-      return res;
-    }
     /**
-     * Evaluate all components at every point in `xs`.
+     * Evaluate all components at every point in `xs` (Horner's method).
+     *
+     * The piece lookup is done once per evaluation point and reused across all
+     * components, and the polynomial is evaluated with Horner's scheme rather
+     * than `Math.pow` — both matter for multivariate and N-D gridded data where
+     * `ndim` is large.
      *
      * @returns Flat row-major array with logical shape `(ndim, xs.length)`:
      *          `out[n * xs.length + q]`.
      */
     evalAll(xs, nu, extrapolate) {
+      const { order, pieces, ndim, breaks, c } = this;
+      const deg = order - 1;
       const L = xs.length;
-      const out = new Float64Array(this.ndim * L);
+      const out = new Float64Array(ndim * L);
+      if (nu > deg) return out;
+      const effDeg = deg - nu;
+      const kstep = pieces * ndim;
+      let mult = null;
+      if (nu !== 0) {
+        mult = new Float64Array(effDeg + 1);
+        for (let k = 0; k <= effDeg; k++) mult[k] = fallingFactorial(deg - k, nu);
+      }
       for (let q = 0; q < L; q++) {
         const xq = xs[q];
-        for (let n = 0; n < this.ndim; n++) {
-          out[n * L + q] = this.evalScalar(n, xq, nu, extrapolate);
+        const i = this.findPiece(xq, extrapolate);
+        if (i < 0) {
+          for (let n = 0; n < ndim; n++) out[n * L + q] = NaN;
+          continue;
+        }
+        const s = xq - breaks[i];
+        const start = i * ndim;
+        if (nu === 0) {
+          for (let n = 0; n < ndim; n++) {
+            let off = start + n;
+            let res = c[off];
+            for (let k = 1; k <= deg; k++) {
+              off += kstep;
+              res = res * s + c[off];
+            }
+            out[n * L + q] = res;
+          }
+        } else {
+          const m = mult;
+          for (let n = 0; n < ndim; n++) {
+            let off = start + n;
+            let res = c[off] * m[0];
+            for (let k = 1; k <= effDeg; k++) {
+              off += kstep;
+              res = res * s + c[off] * m[k];
+            }
+            out[n * L + q] = res;
+          }
         }
       }
       return out;
     }
   };
+  function fallingFactorial(base, nu) {
+    let f = 1;
+    for (let t = 0; t < nu; t++) f *= base - t;
+    return f;
+  }
 
   // src/umv.ts
   function computeSmooth(traceR, traceQtw) {
@@ -155,9 +182,8 @@ var csapsjs = (function (exports) {
     const s = smooth == null ? 0.5 : smooth;
     return s / (s + (1 - s) * k);
   }
-  function makeSpline(x, y2d, w, smooth, normalizedsmooth) {
+  function makeSpline(x, y, N, w, smooth, normalizedsmooth) {
     const M = x.length;
-    const N = y2d.length;
     const dx = new Float64Array(M - 1);
     for (let i = 0; i < M - 1; i++) {
       dx[i] = x[i + 1] - x[i];
@@ -165,18 +191,18 @@ var csapsjs = (function (exports) {
         throw new Error("Items of 'xdata' must satisfy x1 < x2 < ... < xN.");
       }
     }
-    const dydx = new Array(N);
+    const md = M - 1;
+    const dydx = new Float64Array(N * md);
     for (let n = 0; n < N; n++) {
-      const row = new Float64Array(M - 1);
-      const yn = y2d[n];
-      for (let i = 0; i < M - 1; i++) row[i] = (yn[i + 1] - yn[i]) / dx[i];
-      dydx[n] = row;
+      const yb = n * M;
+      const db = n * md;
+      for (let i = 0; i < md; i++) dydx[db + i] = (y[yb + i + 1] - y[yb + i]) / dx[i];
     }
     if (M === 2) {
       const c2 = new Float64Array(2 * 1 * N);
       for (let n = 0; n < N; n++) {
-        c2[0 * N + n] = dydx[n][0];
-        c2[1 * N + n] = y2d[n][0];
+        c2[0 * N + n] = dydx[n * md];
+        c2[1 * N + n] = y[n * M];
       }
       return { pp: new PPoly(c2, Float64Array.from(x), 2, 1, N), smooth: 1 };
     }
@@ -224,44 +250,63 @@ var csapsjs = (function (exports) {
     }
     const B = new Float64Array(m * N);
     for (let i = 0; i < m; i++) {
-      for (let n = 0; n < N; n++) B[i * N + n] = dydx[n][i + 1] - dydx[n][i];
+      for (let n = 0; n < N; n++) {
+        const db = n * md + i;
+        B[i * N + n] = dydx[db + 1] - dydx[db];
+      }
     }
     const U = ldltBandSolve(m, 2, lower, B, N);
-    const uAt = (r, n) => r === 0 || r === M - 1 ? 0 : U[(r - 1) * N + n];
+    const uFull = new Float64Array(M * N);
+    for (let i = 1; i < M - 1; i++) {
+      const src = (i - 1) * N;
+      const dst = i * N;
+      for (let n = 0; n < N; n++) uFull[dst + n] = U[src + n];
+    }
     const d1 = new Float64Array((M - 1) * N);
     for (let i = 0; i < M - 1; i++) {
       const inv = dr[i];
-      for (let n = 0; n < N; n++) d1[i * N + n] = (uAt(i + 1, n) - uAt(i, n)) * inv;
+      const a = i * N;
+      const b = a + N;
+      for (let n = 0; n < N; n++) d1[a + n] = (uFull[b + n] - uFull[a + n]) * inv;
     }
-    const d1At = (r, n) => r === 0 || r === M ? 0 : d1[(r - 1) * N + n];
     const d2 = new Float64Array(M * N);
-    for (let i = 0; i < M; i++) {
-      for (let n = 0; n < N; n++) d2[i * N + n] = d1At(i + 1, n) - d1At(i, n);
+    const lastD1 = (M - 2) * N;
+    const lastD2 = (M - 1) * N;
+    for (let n = 0; n < N; n++) {
+      d2[n] = d1[n];
+      d2[lastD2 + n] = -d1[lastD1 + n];
+    }
+    for (let i = 1; i < M - 1; i++) {
+      const di = i * N;
+      const dim1 = di - N;
+      for (let n = 0; n < N; n++) d2[di + n] = d1[di + n] - d1[dim1 + n];
     }
     const yi = new Float64Array(M * N);
     for (let i = 0; i < M; i++) {
       const f = pp6 * iw[i];
-      for (let n = 0; n < N; n++) yi[i * N + n] = y2d[n][i] - f * d2[i * N + n];
+      const row = i * N;
+      for (let n = 0; n < N; n++) yi[row + n] = y[n * M + i] - f * d2[row + n];
     }
-    const puAt = (r, n) => r === 0 || r === M - 1 ? 0 : p * U[(r - 1) * N + n];
     const pieces = M - 1;
     const c = new Float64Array(4 * pieces * N);
+    const o1 = pieces * N;
+    const o2 = 2 * pieces * N;
+    const o3 = 3 * pieces * N;
     for (let i = 0; i < pieces; i++) {
       const h = dx[i];
       const invh = dr[i];
+      const ri = i * N;
+      const ri1 = ri + N;
       for (let n = 0; n < N; n++) {
-        const pu0 = puAt(i, n);
-        const pu1 = puAt(i + 1, n);
-        const yi0 = yi[i * N + n];
-        const yi1 = yi[(i + 1) * N + n];
-        const c1 = (pu1 - pu0) * invh;
-        const c2 = 3 * pu0;
-        const c3 = (yi1 - yi0) * invh - h * (2 * pu0 + pu1);
-        const c4 = yi0;
-        c[(0 * pieces + i) * N + n] = c1;
-        c[(1 * pieces + i) * N + n] = c2;
-        c[(2 * pieces + i) * N + n] = c3;
-        c[(3 * pieces + i) * N + n] = c4;
+        const pu0 = p * uFull[ri + n];
+        const pu1 = p * uFull[ri1 + n];
+        const yi0 = yi[ri + n];
+        const yi1 = yi[ri1 + n];
+        const ci = ri + n;
+        c[ci] = (pu1 - pu0) * invh;
+        c[o1 + ci] = 3 * pu0;
+        c[o2 + ci] = (yi1 - yi0) * invh - h * (2 * pu0 + pu1);
+        c[o3 + ci] = yi0;
       }
     }
     return { pp: new PPoly(c, Float64Array.from(x), 4, pieces, N), smooth: p };
@@ -273,36 +318,44 @@ var csapsjs = (function (exports) {
     const x = toFloat64(xdata);
     const M = x.length;
     if (x.length < 2) throw new Error("'xdata' must contain at least 2 data points.");
-    let y2d;
+    let y;
+    let N;
     let isVector;
     let transposed = false;
     const first = ydata[0];
     if (Array.isArray(first) || first instanceof Float64Array) {
-      const y = ydata;
-      const R = y.length;
-      const C = y[0].length;
+      const yin = ydata;
+      const R = yin.length;
+      const C = yin[0].length;
       const ndimY = 2;
       const ax = axis < 0 ? ndimY + axis : axis;
       if (ax === 1) {
         if (C !== M) throw new Error(`'ydata' shape[${ax}] (${C}) must equal 'xdata' size (${M}).`);
-        y2d = y.map((row) => Array.from(row));
+        N = R;
+        y = new Float64Array(N * M);
+        for (let n = 0; n < N; n++) {
+          const row = yin[n];
+          const base = n * M;
+          for (let i = 0; i < M; i++) y[base + i] = row[i];
+        }
       } else if (ax === 0) {
         if (R !== M) throw new Error(`'ydata' shape[${ax}] (${R}) must equal 'xdata' size (${M}).`);
         transposed = true;
-        y2d = new Array(C);
-        for (let n = 0; n < C; n++) {
-          const row = new Array(M);
-          for (let i = 0; i < M; i++) row[i] = y[i][n];
-          y2d[n] = row;
+        N = C;
+        y = new Float64Array(N * M);
+        for (let i = 0; i < M; i++) {
+          const row = yin[i];
+          for (let n = 0; n < N; n++) y[n * M + i] = row[n];
         }
       } else {
         throw new Error(`Unsupported axis ${axis} for 2-D ydata.`);
       }
       isVector = false;
     } else {
-      const y = Array.from(ydata);
-      if (y.length !== M) throw new Error(`'ydata' size (${y.length}) must equal 'xdata' size (${M}).`);
-      y2d = [y];
+      const yin = ydata;
+      if (yin.length !== M) throw new Error(`'ydata' size (${yin.length}) must equal 'xdata' size (${M}).`);
+      N = 1;
+      y = toFloat64(yin);
       isVector = true;
     }
     let w;
@@ -312,7 +365,6 @@ var csapsjs = (function (exports) {
       w = toFloat64(weights);
       if (w.length !== M) throw new Error("Weights vector size must equal xdata size.");
     }
-    const N = y2d.length;
     const restore = (flat, L) => {
       if (isVector) {
         const out2 = new Array(L);
@@ -336,13 +388,13 @@ var csapsjs = (function (exports) {
       }
       return out;
     };
-    return { x, y2d, w, restore };
+    return { x, y, N, w, restore };
   }
   var CubicSmoothingSpline = class {
     constructor(xdata, ydata, options = {}) {
       const { weights, smooth = null, axis = -1, normalizedsmooth = false } = options;
       const prep = prepareUnivariate(xdata, ydata, weights, axis);
-      const res = makeSpline(prep.x, prep.y2d, prep.w, smooth ?? null, normalizedsmooth);
+      const res = makeSpline(prep.x, prep.y, prep.N, prep.w, smooth ?? null, normalizedsmooth);
       this.pp = res.pp;
       this.smooth = res.smooth;
       this.restore = prep.restore;
@@ -392,17 +444,19 @@ var csapsjs = (function (exports) {
       const d = this.shape.length;
       const newShape = perm.map((axis) => this.shape[axis]);
       const oldStrides = cStrides(this.shape);
-      const permutedStrides = perm.map((axis) => oldStrides[axis]);
+      const ps = perm.map((axis) => oldStrides[axis]);
       const total = this.data.length;
+      const src = this.data;
       const out = new Float64Array(total);
       const idx = new Array(d).fill(0);
+      let off = 0;
       for (let pos = 0; pos < total; pos++) {
-        let off = 0;
-        for (let a = 0; a < d; a++) off += idx[a] * permutedStrides[a];
-        out[pos] = this.data[off];
+        out[pos] = src[off];
         for (let a = d - 1; a >= 0; a--) {
+          off += ps[a];
           if (++idx[a] < newShape[a]) break;
           idx[a] = 0;
+          off -= ps[a] * newShape[a];
         }
       }
       return new _NdArray(out, newShape);
@@ -484,15 +538,8 @@ var csapsjs = (function (exports) {
       const lastSize = shape[shape.length - 1];
       const total = coeffs.data.length;
       const Nrest = total / lastSize;
-      const y2d = new Array(Nrest);
-      for (let n = 0; n < Nrest; n++) {
-        const row = new Array(lastSize);
-        const base = n * lastSize;
-        for (let col = 0; col < lastSize; col++) row[col] = coeffs.data[base + col];
-        y2d[n] = row;
-      }
       const w = weights[i] ?? new Float64Array(lastSize).fill(1);
-      const res = makeSpline(xs[i], y2d, w, smooth[i], normalizedsmooth);
+      const res = makeSpline(xs[i], coeffs.data, Nrest, w, smooth[i], normalizedsmooth);
       const order = res.pp.order;
       const pcs = res.pp.pieces;
       orders[i] = order;