csaps-js 0.1.0

package/dist/index.cjs

@@ -0,0 +1,665 @@
+'use strict';
+
+// src/banded.ts
+function ldltBandSolve(n, bw, lower, B, nrhs) {
+  const stride = bw + 1;
+  const L = new Float64Array(n * stride);
+  const d = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const oMax = Math.min(bw, i);
+    for (let o = oMax; o >= 1; o--) {
+      const j = i - o;
+      let s = lower[i * stride + o];
+      const kStart = i - bw < 0 ? 0 : i - bw;
+      for (let k = kStart; k < j; k++) {
+        const oi = i - k;
+        const oj = j - k;
+        if (oi <= bw && oj <= bw) {
+          s -= L[i * stride + oi] * L[j * stride + oj] * d[k];
+        }
+      }
+      L[i * stride + o] = s / d[j];
+    }
+    let di = lower[i * stride];
+    for (let o = 1; o <= oMax; o++) {
+      const lio = L[i * stride + o];
+      di -= lio * lio * d[i - o];
+    }
+    if (di === 0 || !Number.isFinite(di)) {
+      throw new Error("Banded LDL\u1D40 solve failed: matrix is singular or ill-conditioned.");
+    }
+    d[i] = di;
+  }
+  const X = new Float64Array(n * nrhs);
+  X.set(B);
+  for (let i = 0; i < n; i++) {
+    const oMax = Math.min(bw, i);
+    for (let c = 0; c < nrhs; c++) {
+      let v = X[i * nrhs + c];
+      for (let o = 1; o <= oMax; o++) {
+        v -= L[i * stride + o] * X[(i - o) * nrhs + c];
+      }
+      X[i * nrhs + c] = v;
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    const inv = 1 / d[i];
+    for (let c = 0; c < nrhs; c++) {
+      X[i * nrhs + c] *= inv;
+    }
+  }
+  for (let i = n - 1; i >= 0; i--) {
+    const oMaxUp = Math.min(bw, n - 1 - i);
+    for (let c = 0; c < nrhs; c++) {
+      let v = X[i * nrhs + c];
+      for (let o = 1; o <= oMaxUp; o++) {
+        v -= L[(i + o) * stride + o] * X[(i + o) * nrhs + c];
+      }
+      X[i * nrhs + c] = v;
+    }
+  }
+  return X;
+}
+
+// src/ppoly.ts
+var PPoly = class {
+  constructor(c, breaks, order, pieces, ndim) {
+    this.c = c;
+    this.breaks = breaks;
+    this.order = order;
+    this.pieces = pieces;
+    this.ndim = ndim;
+  }
+  /** Locate the piece index for `xq`, or `-1` when out of bounds and not extrapolating. */
+  findPiece(xq, extrapolate) {
+    const b = this.breaks;
+    const last = this.pieces;
+    if (xq < b[0]) return extrapolate ? 0 : -1;
+    if (xq > b[last]) return extrapolate ? this.pieces - 1 : -1;
+    if (xq >= b[last]) return this.pieces - 1;
+    let lo = 0;
+    let hi = this.pieces - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (b[mid] <= xq) lo = mid;
+      else hi = mid - 1;
+    }
+    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`.
+   *
+   * @returns Flat row-major array with logical shape `(ndim, xs.length)`:
+   *          `out[n * xs.length + q]`.
+   */
+  evalAll(xs, nu, extrapolate) {
+    const L = xs.length;
+    const out = new Float64Array(this.ndim * L);
+    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);
+      }
+    }
+    return out;
+  }
+};
+
+// src/umv.ts
+function computeSmooth(traceR, traceQtw) {
+  return 1 / (1 + traceR / (6 * traceQtw));
+}
+function normalizeSmooth(x, w, smooth) {
+  const n = x.length;
+  let xmin = x[0];
+  let xmax = x[0];
+  for (let i = 1; i < n; i++) {
+    if (x[i] < xmin) xmin = x[i];
+    if (x[i] > xmax) xmax = x[i];
+  }
+  const span = xmax - xmin;
+  let sumDx2 = 0;
+  for (let i = 0; i < n - 1; i++) {
+    const d = x[i + 1] - x[i];
+    sumDx2 += d * d;
+  }
+  const effX = 1 + span * span / sumDx2;
+  let sw = 0;
+  let sw2 = 0;
+  for (let i = 0; i < n; i++) {
+    sw += w[i];
+    sw2 += w[i] * w[i];
+  }
+  const effW = sw * sw / sw2;
+  const k = 80 * Math.pow(span, 3) * Math.pow(n, -2) * Math.pow(effX, -0.5) * Math.pow(effW, -0.5);
+  const s = smooth == null ? 0.5 : smooth;
+  return s / (s + (1 - s) * k);
+}
+function makeSpline(x, y2d, 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];
+    if (!(dx[i] > 0)) {
+      throw new Error("Items of 'xdata' must satisfy x1 < x2 < ... < xN.");
+    }
+  }
+  const dydx = new Array(N);
+  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;
+  }
+  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];
+    }
+    return { pp: new PPoly(c2, Float64Array.from(x), 2, 1, N), smooth: 1 };
+  }
+  const m = M - 2;
+  const dr = new Float64Array(M - 1);
+  for (let i = 0; i < M - 1; i++) dr[i] = 1 / dx[i];
+  const iw = new Float64Array(M);
+  for (let i = 0; i < M; i++) iw[i] = 1 / w[i];
+  const qd = new Float64Array(m);
+  for (let i = 0; i < m; i++) {
+    const a = dr[i];
+    const b = dr[i] + dr[i + 1];
+    const cc = dr[i + 1];
+    qd[i] = a * a * iw[i] + b * b * iw[i + 1] + cc * cc * iw[i + 2];
+  }
+  const q1 = new Float64Array(Math.max(0, m - 1));
+  for (let i = 0; i < m - 1; i++) {
+    q1[i] = -dr[i + 1] * (dr[i] + dr[i + 1]) * iw[i + 1] - dr[i + 1] * (dr[i + 1] + dr[i + 2]) * iw[i + 2];
+  }
+  const q2 = new Float64Array(Math.max(0, m - 2));
+  for (let i = 0; i < m - 2; i++) {
+    q2[i] = dr[i + 1] * dr[i + 2] * iw[i + 2];
+  }
+  let p;
+  if (normalizedsmooth) {
+    p = normalizeSmooth(x, w, smooth);
+  } else if (smooth == null) {
+    let traceR = 0;
+    let traceQ = 0;
+    for (let i = 0; i < m; i++) {
+      traceR += 2 * (dx[i] + dx[i + 1]);
+      traceQ += qd[i];
+    }
+    p = computeSmooth(traceR, traceQ);
+  } else {
+    p = smooth;
+  }
+  const pp6 = 6 * (1 - p);
+  const lower = new Float64Array(m * 3);
+  for (let i = 0; i < m; i++) {
+    const rii = 2 * (dx[i] + dx[i + 1]);
+    lower[i * 3] = pp6 * qd[i] + p * rii;
+    if (i >= 1) lower[i * 3 + 1] = pp6 * q1[i - 1] + p * dx[i];
+    if (i >= 2) lower[i * 3 + 2] = pp6 * q2[i - 2];
+  }
+  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];
+  }
+  const U = ldltBandSolve(m, 2, lower, B, N);
+  const uAt = (r, n) => r === 0 || r === M - 1 ? 0 : U[(r - 1) * N + 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 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 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 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);
+  for (let i = 0; i < pieces; i++) {
+    const h = dx[i];
+    const invh = dr[i];
+    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;
+    }
+  }
+  return { pp: new PPoly(c, Float64Array.from(x), 4, pieces, N), smooth: p };
+}
+function toFloat64(a) {
+  return a instanceof Float64Array ? a : Float64Array.from(a);
+}
+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 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 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));
+    } 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;
+      }
+    } 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];
+    isVector = true;
+  }
+  let w;
+  if (weights == null) {
+    w = new Float64Array(M).fill(1);
+  } else {
+    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);
+      for (let q = 0; q < L; q++) out2[q] = flat[q];
+      return out2;
+    }
+    if (transposed) {
+      const out2 = new Array(L);
+      for (let q = 0; q < L; q++) {
+        const row = new Array(N);
+        for (let n = 0; n < N; n++) row[n] = flat[n * L + q];
+        out2[q] = row;
+      }
+      return out2;
+    }
+    const out = new Array(N);
+    for (let n = 0; n < N; n++) {
+      const row = new Array(L);
+      for (let q = 0; q < L; q++) row[q] = flat[n * L + q];
+      out[n] = row;
+    }
+    return out;
+  };
+  return { x, y2d, 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);
+    this.pp = res.pp;
+    this.smooth = res.smooth;
+    this.restore = prep.restore;
+  }
+  /** Evaluate the spline (or one of its derivatives) at the sites `xi`. */
+  evaluate(xi, options = {}) {
+    const { nu = 0, extrapolate = true } = options;
+    const xs = toFloat64(xi);
+    const flat = this.pp.evalAll(xs, nu, extrapolate);
+    return this.restore(flat, xs.length);
+  }
+  /** Breakpoints (data sites) of the piecewise polynomial. */
+  get breaks() {
+    return Array.from(this.pp.breaks);
+  }
+  /** Spline description: breakpoints, raw coefficients and shape metadata. */
+  get spline() {
+    return {
+      breaks: Array.from(this.pp.breaks),
+      coeffs: this.pp.c,
+      order: this.pp.order,
+      pieces: this.pp.pieces,
+      ndim: this.pp.ndim
+    };
+  }
+  /** Internal piecewise polynomial (used by the N-D grid spline). */
+  get _pp() {
+    return this.pp;
+  }
+};
+
+// src/ndarray.ts
+var NdArray = class _NdArray {
+  constructor(data, shape) {
+    this.data = data;
+    this.shape = shape;
+  }
+  get size() {
+    return this.data.length;
+  }
+  /** Reinterpret the buffer with a new shape (must keep the same element count). */
+  reshape(shape) {
+    return new _NdArray(this.data, shape.slice());
+  }
+  /** Return a new array with axes permuted according to `perm`, materialized C-contiguous. */
+  transpose(perm) {
+    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 total = this.data.length;
+    const out = new Float64Array(total);
+    const idx = new Array(d).fill(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];
+      for (let a = d - 1; a >= 0; a--) {
+        if (++idx[a] < newShape[a]) break;
+        idx[a] = 0;
+      }
+    }
+    return new _NdArray(out, newShape);
+  }
+};
+function cStrides(shape) {
+  const d = shape.length;
+  const strides = new Array(d).fill(1);
+  for (let a = d - 2; a >= 0; a--) strides[a] = strides[a + 1] * shape[a + 1];
+  return strides;
+}
+function prod(xs) {
+  let p = 1;
+  for (const x of xs) p *= x;
+  return p;
+}
+function flattenNested(y) {
+  const shape = [];
+  let node = y;
+  while (Array.isArray(node)) {
+    shape.push(node.length);
+    node = node[0];
+  }
+  const data = new Float64Array(prod(shape));
+  let k = 0;
+  const fill = (n, depth) => {
+    if (depth === shape.length) {
+      data[k++] = n;
+      return;
+    }
+    const a = n;
+    if (a.length !== shape[depth]) {
+      throw new Error("flattenNested: input array is ragged (non-rectangular).");
+    }
+    for (let i = 0; i < a.length; i++) fill(a[i], depth + 1);
+  };
+  fill(y, 0);
+  return { data, shape };
+}
+function nestArray(data, shape) {
+  const strides = cStrides(shape);
+  const build = (depth, offset) => {
+    if (depth === shape.length - 1) {
+      const row = new Array(shape[depth]);
+      for (let i = 0; i < shape[depth]; i++) row[i] = data[offset + i];
+      return row;
+    }
+    const arr = new Array(shape[depth]);
+    for (let i = 0; i < shape[depth]; i++) arr[i] = build(depth + 1, offset + i * strides[depth]);
+    return arr;
+  };
+  return build(0, 0);
+}
+
+// src/ndg.ts
+function toFloat642(a) {
+  return a instanceof Float64Array ? a : Float64Array.from(a);
+}
+function prepareVectors(data, name, minSize = 2) {
+  if (!Array.isArray(data)) throw new TypeError(`'${name}' must be a sequence of 1-D vectors.`);
+  return data.map((d, axis) => {
+    const v = toFloat642(d);
+    if (v.length < minSize) {
+      throw new Error(`'${name}' must contain at least ${minSize} points for axis ${axis}.`);
+    }
+    return v;
+  });
+}
+function buildGrid(xs, yNd, weights, smooth, normalizedsmooth) {
+  const d = xs.length;
+  const orders = new Array(d);
+  const pieces = new Array(d);
+  const smooths = new Array(d);
+  const permute = [d - 1];
+  for (let a = 0; a < d - 1; a++) permute.push(a);
+  let coeffs = yNd;
+  let shape = yNd.shape.slice();
+  for (let i = d - 1; i >= 0; i--) {
+    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 order = res.pp.order;
+    const pcs = res.pp.pieces;
+    orders[i] = order;
+    pieces[i] = pcs;
+    smooths[i] = res.smooth;
+    const op = order * pcs;
+    const flat = new Float64Array(Nrest * op);
+    for (let k = 0; k < order; k++) {
+      for (let ii = 0; ii < pcs; ii++) {
+        const j = k * pcs + ii;
+        const cBase = j * Nrest;
+        for (let n = 0; n < Nrest; n++) flat[n * op + j] = res.pp.c[cBase + n];
+      }
+    }
+    const newShape = shape.slice(0, -1);
+    newShape.push(op);
+    coeffs = new NdArray(flat, newShape).transpose(permute);
+    shape = coeffs.shape.slice();
+  }
+  return { F: coeffs, breaks: xs, orders, pieces, smooths };
+}
+function evalGrid(built, xiList, nu, extrapolate) {
+  const { F, breaks, orders, pieces } = built;
+  const d = breaks.length;
+  const permute = [d - 1];
+  for (let a = 0; a < d - 1; a++) permute.push(a);
+  let coeffs = F;
+  let shape = F.shape.slice();
+  for (let i = d - 1; i >= 0; i--) {
+    const order = orders[i];
+    const pcs = pieces[i];
+    const lastSize = shape[shape.length - 1];
+    const total = coeffs.data.length;
+    const Nrest = total / lastSize;
+    const cc = new Float64Array(order * pcs * Nrest);
+    for (let k = 0; k < order; k++) {
+      for (let ii = 0; ii < pcs; ii++) {
+        const j = k * pcs + ii;
+        const dst = (k * pcs + ii) * Nrest;
+        for (let n = 0; n < Nrest; n++) cc[dst + n] = coeffs.data[n * lastSize + j];
+      }
+    }
+    const pp = new PPoly(cc, breaks[i], order, pcs, Nrest);
+    const xi = xiList[i];
+    const Li = xi.length;
+    const out = pp.evalAll(xi, nu[i] ?? 0, extrapolate);
+    const newShape = shape.slice(0, -1);
+    newShape.push(Li);
+    coeffs = new NdArray(out, newShape).transpose(permute);
+    shape = coeffs.shape.slice();
+  }
+  return coeffs;
+}
+function normalizeSmooth2(smooth, d) {
+  if (smooth == null) return new Array(d).fill(null);
+  if (Array.isArray(smooth)) {
+    if (smooth.length !== d) {
+      throw new Error(`Number of smoothing values (${smooth.length}) must equal dimensions (${d}).`);
+    }
+    return smooth.map((s) => s == null ? null : s);
+  }
+  return new Array(d).fill(smooth);
+}
+function normalizeWeights(weights, d, sizes) {
+  if (weights == null) return new Array(d).fill(void 0);
+  const w = weights;
+  const firstIsVector = Array.isArray(w[0]) || w[0] instanceof Float64Array;
+  let list;
+  if (!firstIsVector) {
+    if (d !== 1) throw new Error("'weights' must be a sequence of vectors, one per axis.");
+    list = [weights];
+  } else {
+    list = weights;
+  }
+  if (list.length !== d) throw new Error(`'weights' dimensions (${list.length}) must equal 'xdata' dimensions (${d}).`);
+  return list.map((wv, axis) => {
+    const v = toFloat642(wv);
+    if (v.length !== sizes[axis]) {
+      throw new Error(`'weights' size (${v.length}) must equal 'xdata' size (${sizes[axis]}) for axis ${axis}.`);
+    }
+    return v;
+  });
+}
+var NdGridCubicSmoothingSpline = class {
+  constructor(xdata, ydata, options = {}) {
+    const xs = prepareVectors(xdata, "xdata");
+    const d = xs.length;
+    const sizes = xs.map((v) => v.length);
+    const { data, shape } = flattenNested(ydata);
+    if (shape.length !== d) {
+      throw new Error(`'ydata' must have ${d} dimensions according to 'xdata' (got ${shape.length}).`);
+    }
+    for (let a = 0; a < d; a++) {
+      if (shape[a] !== sizes[a]) {
+        throw new Error(`'ydata' size (${shape[a]}) and 'xdata' size (${sizes[a]}) mismatch for axis ${a}.`);
+      }
+    }
+    const smooth = normalizeSmooth2(options.smooth, d);
+    const weights = normalizeWeights(options.weights, d, sizes);
+    this.built = buildGrid(xs, new NdArray(data, shape), weights, smooth, options.normalizedsmooth ?? false);
+    this.smooth = this.built.smooths;
+  }
+  /** Evaluate the spline on the grid defined by the sequence of site vectors `xi`. */
+  evaluate(xi, options = {}) {
+    const d = this.built.breaks.length;
+    const xiList = prepareVectors(xi, "xi", 1);
+    if (xiList.length !== d) throw new Error(`'xi' must have length ${d} according to the grid.`);
+    const nu = options.nu ?? new Array(d).fill(0);
+    const extrapolate = options.extrapolate ?? true;
+    const result = evalGrid(this.built, xiList, nu, extrapolate);
+    return nestArray(result.data, result.shape);
+  }
+  /** Spline description: per-axis breakpoints, raw coefficient tensor and shape metadata. */
+  get spline() {
+    return {
+      breaks: this.built.breaks.map((b) => Array.from(b)),
+      coeffs: this.built.F.data,
+      coeffsShape: this.built.F.shape.slice(),
+      order: this.built.orders.slice(),
+      pieces: this.built.pieces.slice()
+    };
+  }
+};
+
+// src/csaps.ts
+function isVectorList(x) {
+  return Array.isArray(x) && x.length > 0 && (Array.isArray(x[0]) || x[0] instanceof Float64Array);
+}
+function isArrayLike(x) {
+  return Array.isArray(x) || x instanceof Float64Array;
+}
+function csaps(xdata, ydata, arg3, arg4) {
+  let xidata;
+  let options;
+  if (arg3 === void 0) {
+    xidata = void 0;
+    options = arg4 ?? {};
+  } else if (isArrayLike(arg3)) {
+    xidata = arg3;
+    options = arg4 ?? {};
+  } else {
+    xidata = void 0;
+    options = arg3 ?? {};
+  }
+  const grid = isVectorList(xdata);
+  const spline = grid ? new NdGridCubicSmoothingSpline(xdata, ydata, {
+    weights: options.weights,
+    smooth: options.smooth,
+    normalizedsmooth: options.normalizedsmooth
+  }) : new CubicSmoothingSpline(xdata, ydata, {
+    weights: options.weights,
+    smooth: typeof options.smooth === "number" ? options.smooth : options.smooth ?? null,
+    axis: options.axis,
+    normalizedsmooth: options.normalizedsmooth
+  });
+  if (xidata === void 0) return spline;
+  const values = grid ? spline.evaluate(xidata) : spline.evaluate(xidata);
+  const sm = options.smooth;
+  const autoSmooth = Array.isArray(sm) ? sm.some((s) => s == null) : sm == null;
+  if (autoSmooth) {
+    return { values, smooth: spline.smooth };
+  }
+  return values;
+}
+
+exports.CubicSmoothingSpline = CubicSmoothingSpline;
+exports.NdGridCubicSmoothingSpline = NdGridCubicSmoothingSpline;
+exports.PPoly = PPoly;
+exports.csaps = csaps;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map