csaps-js 0.1.0 → 0.1.1

package/dist/index.js

@@ -84,43 +84,70 @@ var PPoly = class {
     }
     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) {
@@ -152,9 +179,8 @@ function normalizeSmooth(x, w, smooth) {
   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];
@@ -162,18 +188,18 @@ function makeSpline(x, y2d, w, smooth, normalizedsmooth) {
       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 };
   }
@@ -221,44 +247,63 @@ function makeSpline(x, y2d, w, smooth, normalizedsmooth) {
   }
   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 };
@@ -270,36 +315,44 @@ function prepareUnivariate(xdata, ydata, weights, axis) {
   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;
@@ -309,7 +362,6 @@ function prepareUnivariate(xdata, ydata, weights, axis) {
     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);
@@ -333,13 +385,13 @@ function prepareUnivariate(xdata, ydata, weights, axis) {
     }
     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;
@@ -389,17 +441,19 @@ var NdArray = class _NdArray {
     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);
@@ -481,15 +535,8 @@ function buildGrid(xs, yNd, weights, smooth, normalizedsmooth) {
     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;