@uwdata/mosaic-plot 0.5.0

package/src/marks/RasterTileMark.js

@@ -0,0 +1,331 @@
+import { coordinator } from '@uwdata/mosaic-core';
+import { Query, count, isBetween, lt, lte, neq, sql, sum } from '@uwdata/mosaic-sql';
+import { scale } from '@observablehq/plot';
+import { extentX, extentY } from './util/extent.js';
+import { isColor } from './util/is-color.js';
+import { createCanvas, raster, opacityMap, palette } from './util/raster.js';
+import { Grid2DMark } from './Grid2DMark.js';
+import { binField } from './util/bin-field.js';
+
+export class RasterTileMark extends Grid2DMark {
+  constructor(source, options) {
+    const { origin = [0, 0], dim = 'xy', ...markOptions } = options;
+    super('image', source, markOptions);
+
+    // TODO: make part of data source instead of options?
+    this.origin = origin;
+    this.tileX = dim.toLowerCase().includes('x');
+    this.tileY = dim.toLowerCase().includes('y');
+  }
+
+  setPlot(plot, index) {
+    const update = () => { if (this.stats) this.rasterize(); };
+    plot.addAttributeListener('schemeColor', update);
+    super.setPlot(plot, index);
+  }
+
+  requestQuery() {
+    return this.requestTiles();
+  }
+
+  query(filter = []) {
+    this._filter = filter;
+    // we will submit our own queries
+    return null;
+  }
+
+  tileQuery(extent) {
+    const { plot, binType, binPad, channels, densityMap, source } = this;
+    const [[x0, x1], [y0, y1]] = extent;
+    const [nx, ny] = this.bins;
+    const bx = binField(this, 'x');
+    const by = binField(this, 'y');
+    const rx = !!plot.getAttribute('xReverse');
+    const ry = !!plot.getAttribute('yReverse');
+    const x = bin1d(bx, x0, x1, nx, rx, binPad);
+    const y = bin1d(by, y0, y1, ny, ry, binPad);
+
+    // with padded bins, include the entire domain extent
+    // if the bins are flush, exclude the extent max
+    const bounds = binPad
+      ? [isBetween(bx, [x0, x1]), isBetween(by, [y0, y1])]
+      : [lte(x0, bx), lt(bx, x1), lte(y0, by), lt(by, y1)];
+
+    const q = Query
+      .from(source.table)
+      .where(bounds);
+
+    const groupby = this.groupby = [];
+    let agg = count();
+    for (const c of channels) {
+      if (Object.hasOwn(c, 'field')) {
+        const { channel, field } = c;
+        if (field.aggregate) {
+          agg = field;
+          densityMap[channel] = true;
+        } else if (channel === 'weight') {
+          agg = sum(field);
+        } else if (channel !== 'x' && channel !== 'y') {
+          q.select({ [channel]: field });
+          groupby.push(channel);
+        }
+      }
+    }
+
+    return binType === 'linear'
+      ? binLinear2d(q, x, y, agg, nx, groupby)
+      : bin2d(q, x, y, agg, nx, groupby);
+  }
+
+  async requestTiles() {
+    // get coordinator, cancel prior prefetch queries
+    const mc = coordinator();
+    if (this.prefetch) mc.cancel(this.prefetch);
+
+    // get view extent info
+    const { binPad, tileX, tileY, origin: [tx, ty] } = this;
+    const [m, n] = this.bins = this.binDimensions(this);
+    const [x0, x1] = extentX(this, this._filter);
+    const [y0, y1] = extentY(this, this._filter);
+    const xspan = x1 - x0;
+    const yspan = y1 - y0;
+    const xx = Math.floor((x0 - tx) * (m - binPad) / xspan);
+    const yy = Math.floor((y0 - ty) * (n - binPad) / yspan);
+
+    const tileExtent = (i, j) => [
+      [tx + i * xspan, tx + (i + 1) * xspan],
+      [ty + j * yspan, ty + (j + 1) * yspan]
+    ];
+
+    // get tile coords that overlap current view extent
+    const i0 = Math.floor((x0 - tx) / xspan);
+    const i1 = tileX ? tileFloor((x1 - tx) / xspan) : i0;
+    const j0 = Math.floor((y0 - ty) / yspan);
+    const j1 = tileY ? tileFloor((y1 - ty) / yspan) : j0;
+
+    // query for currently needed data tiles
+    const coords = [];
+    for (let i = i0; i <= i1; ++i) {
+      for (let j = j0; j <= j1; ++j) {
+        coords.push([i, j]);
+      }
+    }
+    const queries = coords.map(
+      ([i, j]) => mc.query(this.tileQuery(tileExtent(i, j)))
+    );
+
+    // prefetch tiles along periphery of current tiles
+    const prefetchCoords = [];
+    if (tileX) {
+      for (let j = j0; j <= j1; ++j) {
+        prefetchCoords.push([i1 + 1, j]);
+        prefetchCoords.push([i0 - 1, j]);
+      }
+    }
+    if (tileY) {
+      const x0 = tileX ? i0 - 1 : i0;
+      const x1 = tileX ? i1 + 1 : i1;
+      for (let i = x0; i <= x1; ++i) {
+        prefetchCoords.push([i, j1 + 1]);
+        prefetchCoords.push([i, j0 - 1]);
+      }
+    }
+    this.prefetch = prefetchCoords.map(
+      ([i, j]) => mc.prefetch(this.tileQuery(tileExtent(i, j)))
+    );
+
+    // wait for tile queries to complete, then update
+    const tiles = await Promise.all(queries);
+    this.grids = [{ grid: processTiles(m, n, xx, yy, coords, tiles) }];
+    this.convolve().update();
+  }
+
+  convolve() {
+    return super.convolve().rasterize();
+  }
+
+  rasterize() {
+    const { bins, kde, groupby } = this;
+    const [ w, h ] = bins;
+
+    // raster data
+    const { canvas, ctx, img } = imageData(this, w, h);
+
+    // scale function to map densities to [0, 1]
+    const s = imageScale(this);
+
+    // gather color domain as needed
+    const idx = groupby.indexOf(this.channelField('fill')?.as);
+    const domain = idx < 0 ? [] : kde.map(({ key }) => key[idx]);
+
+    // generate raster images
+    this.data = kde.map(grid => {
+      const palette = imagePalette(this, domain, grid.key?.[idx]);
+      raster(grid, img.data, w, h, s, palette);
+      ctx.putImageData(img, 0, 0);
+      return { src: canvas.toDataURL() };
+    });
+
+    return this;
+  }
+
+  plotSpecs() {
+    const { type, data, plot } = this;
+    const options = {
+      src: 'src',
+      width: plot.innerWidth(),
+      height: plot.innerHeight(),
+      preserveAspectRatio: 'none',
+      imageRendering: this.channel('imageRendering')?.value,
+      frameAnchor: 'middle'
+    };
+    return [{ type, data, options }];
+  }
+}
+
+function processTiles(m, n, x, y, coords, tiles) {
+  const grid = new Float64Array(m * n);
+  tiles.forEach((data, index) => {
+    const [i, j] = coords[index];
+    const tx = i * m - x;
+    const ty = j * n - y;
+    copy(m, n, grid, data, tx, ty);
+  });
+  return grid;
+}
+
+function copy(m, n, grid, values, tx, ty) {
+  // index = row + col * width
+  const num = values.numRows;
+  if (num === 0) return;
+  const index = values.getChild('index').toArray();
+  const value = values.getChild('value').toArray();
+  for (let row = 0; row < num; ++row) {
+    const idx = index[row];
+    const i = tx + (idx % m);
+    const j = ty + Math.floor(idx / m);
+    if (0 <= i && i < m && 0 <= j && j < n) {
+      grid[i + j * m] = value[row];
+    }
+  }
+}
+
+function imageData(mark, w, h) {
+  if (!mark.image || mark.image.w !== w || mark.image.h !== h) {
+    const canvas = createCanvas(w, h);
+    const ctx = canvas.getContext('2d', { willReadFrequently: true });
+    const img = ctx.getImageData(0, 0, w, h);
+    mark.image = { canvas, ctx, img, w, h };
+  }
+  return mark.image;
+}
+
+function imageScale(mark) {
+  const { densityMap, kde, plot } = mark;
+  let domain = densityMap.fill && plot.getAttribute('colorDomain');
+
+  // compute kde grid extents if no explicit domain
+  if (!domain) {
+    let lo = 0, hi = 0;
+    kde.forEach(grid => {
+      for (const v of grid) {
+        if (v < lo) lo = v;
+        if (v > hi) hi = v;
+      }
+    });
+    domain = (lo === 0 && hi === 0) ? [0, 1] : [lo, hi];
+  }
+
+  const type = plot.getAttribute('colorScale');
+  return scale({ x: { type, domain, range: [0, 1] } }).apply;
+}
+
+function imagePalette(mark, domain, value, steps = 1024) {
+  const { densityMap, plot } = mark;
+  const scheme = plot.getAttribute('colorScheme');
+
+  // initialize color to constant fill, if specified
+  const fill = mark.channel('fill');
+  let color = isColor(fill?.value) ? fill.value : undefined;
+
+  if (densityMap.fill || (scheme && !color)) {
+    if (scheme) {
+      try {
+        return palette(
+          steps,
+          scale({color: { scheme, domain: [0, 1] }}).interpolate
+        );
+      } catch (err) {
+        console.warn(err);
+      }
+    }
+  } else if (domain.length) {
+    // fill is based on data values
+    const range = plot.getAttribute('colorRange');
+    const spec = {
+      domain,
+      range,
+      scheme: scheme || (range ? undefined : 'tableau10')
+    };
+    color = scale({ color: spec }).apply(value);
+  }
+
+  return palette(steps, opacityMap(color));
+}
+
+function bin1d(x, x0, x1, n, reverse, pad) {
+  const d = (n - pad) / (x1 - x0);
+  const f = d !== 1 ? ` * ${d}::DOUBLE` : '';
+  return reverse
+    ? sql`(${x1} - ${x}::DOUBLE)${f}`
+    : sql`(${x}::DOUBLE - ${x0})${f}`;
+}
+
+function bin2d(q, xp, yp, value, xn, groupby) {
+  return q
+    .select({
+      index: sql`FLOOR(${xp})::INTEGER + FLOOR(${yp})::INTEGER * ${xn}`,
+      value
+    })
+    .groupby('index', groupby);
+}
+
+function binLinear2d(q, xp, yp, value, xn, groupby) {
+  const w = value.column ? `* ${value.column}` : '';
+  const subq = (i, w) => q.clone().select({ xp, yp, i, w });
+
+  // grid[xu + yu * xn] += (xv - xp) * (yv - yp) * wi;
+  const a = subq(
+    sql`FLOOR(xp)::INTEGER + FLOOR(yp)::INTEGER * ${xn}`,
+    sql`(FLOOR(xp)::INTEGER + 1 - xp) * (FLOOR(yp)::INTEGER + 1 - yp)${w}`
+  );
+
+  // grid[xu + yv * xn] += (xv - xp) * (yp - yu) * wi;
+  const b = subq(
+    sql`FLOOR(xp)::INTEGER + (FLOOR(yp)::INTEGER + 1) * ${xn}`,
+    sql`(FLOOR(xp)::INTEGER + 1 - xp) * (yp - FLOOR(yp)::INTEGER)${w}`
+  );
+
+  // grid[xv + yu * xn] += (xp - xu) * (yv - yp) * wi;
+  const c = subq(
+    sql`FLOOR(xp)::INTEGER + 1 + FLOOR(yp)::INTEGER * ${xn}`,
+    sql`(xp - FLOOR(xp)::INTEGER) * (FLOOR(yp)::INTEGER + 1 - yp)${w}`
+  );
+
+  // grid[xv + yv * xn] += (xp - xu) * (yp - yu) * wi;
+  const d = subq(
+    sql`FLOOR(xp)::INTEGER + 1 + (FLOOR(yp)::INTEGER + 1) * ${xn}`,
+    sql`(xp - FLOOR(xp)::INTEGER) * (yp - FLOOR(yp)::INTEGER)${w}`
+  );
+
+  return Query
+    .from(Query.unionAll(a, b, c, d))
+    .select({ index: 'i', value: sum('w') }, groupby)
+    .groupby('index', groupby)
+    .having(neq('value', 0));
+}
+
+function tileFloor(value) {
+  const floored = Math.floor(value);
+  return floored === value ? floored - 1 : floored;
+}

package/src/marks/RegressionMark.js

@@ -0,0 +1,117 @@
+import { range } from 'd3';
+import {
+  Query, max, min, castDouble, isNotNull,
+  regrIntercept, regrSlope, regrCount,
+  regrSYY, regrSXX, regrAvgX
+} from '@uwdata/mosaic-sql';
+import { qt } from './util/stats.js';
+import { Mark, channelOption } from './Mark.js';
+import { handleParam } from './util/handle-param.js';
+import { toDataArray } from './util/to-data-array.js';
+
+export class RegressionMark extends Mark {
+  constructor(source, options) {
+    const { ci = 0.95, precision = 4, ...channels } = options;
+    super('line', source, channels);
+    const update = () => {
+      return this.modelFit ? this.confidenceBand().update() : null
+    };
+    handleParam(this, 'ci', ci, update);
+    handleParam(this, 'precision', precision, update);
+  }
+
+  query(filter = []) {
+    const x = this.channelField('x').as;
+    const y = this.channelField('y').as;
+    const groupby = Array.from(new Set(
+      ['stroke', 'z', 'fx', 'fy'].flatMap(c => this.channelField(c)?.as || [])
+    ));
+
+    return Query
+      .from(super.query(filter))
+      .select({
+        intercept: regrIntercept(y, x),
+        slope: regrSlope(y, x),
+        n: regrCount(y, x),
+        ssy: regrSYY(y, x),
+        ssx: regrSXX(y, x),
+        xm: regrAvgX(y, x),
+        x0: castDouble(min(x).where(isNotNull(y))),
+        x1: castDouble(max(x).where(isNotNull(y)))
+      })
+      .select(groupby)
+      .groupby(groupby);
+  }
+
+  queryResult(data) {
+    this.modelFit = toDataArray(data);
+
+    // regression line
+    this.lineData = this.modelFit.flatMap(m => linePoints(m));
+
+    // prepare confidence band
+    return this.confidenceBand();
+  }
+
+  confidenceBand() {
+    // regression ci area
+    const { ci, modelFit, precision, plot } = this;
+    const w = plot.innerWidth();
+    this.areaData = ci ? modelFit.flatMap(m => areaPoints(ci, precision, m, w)) : null;
+    return this;
+  }
+
+  plotSpecs() {
+    const { lineData, areaData, channels, ci } = this;
+    const lopt = { x: 'x', y: 'y' };
+    const aopt = { x: 'x', y1: 'y1', y2: 'y2', fillOpacity: 0.1 };
+
+    for (const c of channels) {
+      switch (c.channel) {
+        case 'x':
+        case 'y':
+        case 'fill':
+          break;
+        case 'stroke':
+          lopt.stroke = aopt.fill = channelOption(c);
+          break;
+        case 'strokeOpacity':
+          lopt.strokeOpacity = channelOption(c);
+          break;
+        case 'fillOpacity':
+          aopt.fillOpacity = channelOption(c);
+          break;
+        default:
+          lopt[c.channel] = aopt[c.channel] = channelOption(c);
+          break;
+      }
+    }
+
+    return [
+      ...(ci ? [{ type: 'areaY', data: areaData, options: aopt }] : []),
+      { type: 'line', data: lineData, options: lopt }
+    ];
+  }
+}
+
+function linePoints(model) {
+  // eslint-disable-next-line no-unused-vars
+  const { x0, x1, xm, intercept, slope, n, ssx, ssy, ...rest } = model;
+  return [
+    { x: x0, y: intercept + x0 * slope, ...rest },
+    { x: x1, y: intercept + x1 * slope, ...rest }
+  ];
+}
+
+function areaPoints(ci, precision, model, width) {
+  const { x0, x1, xm, intercept, slope, n, ssx, ssy, ...rest } = model;
+  const pp = precision * (x1 - x0) / width;
+  const t_sy = qt((1 - ci) / 2, n - 2) * Math.sqrt(ssy / (n - 2));
+  return range(x0, x1 - pp / 2, pp)
+    .concat(x1)
+    .map(x => {
+      const y = intercept + x * slope;
+      const ye = t_sy * Math.sqrt(1 / n + (x - xm) ** 2 / ssx);
+      return { x, y1: y - ye, y2: y + ye, ...rest };
+    });
+}

package/src/marks/util/bin-field.js

@@ -0,0 +1,17 @@
+import { epoch_ms, sql } from '@uwdata/mosaic-sql';
+
+export function binField(mark, channel, expr) {
+  if (!mark.stats) return field;
+  const { field } = mark.channelField(channel);
+  const { type } = mark.stats[field.column];
+  expr = expr ?? field;
+  return type === 'date' ? epoch_ms(expr) : expr;
+}
+
+export function bin1d(x, x0, x1, n, reverse = false, pad = 1) {
+  const d = (n - pad) / (x1 - x0);
+  const f = d !== 1 ? ` * ${d}::DOUBLE` : '';
+  return reverse
+    ? sql`(${+x1} - ${x}::DOUBLE)${f}`
+    : sql`(${x}::DOUBLE - ${+x0})${f}`;
+}

package/src/marks/util/density.js

@@ -0,0 +1,226 @@
+// Deriche's approximation of Gaussian smoothing
+// Adapted from Getreuer's C implementation (BSD license)
+// https://www.ipol.im/pub/art/2013/87/gaussian_20131215.tgz
+// http://dev.ipol.im/~getreuer/code/doc/gaussian_20131215_doc/gaussian__conv__deriche_8c.html
+
+export function dericheConfig(sigma, negative = false) {
+  // compute causal filter coefficients
+  const a = new Float64Array(5);
+  const bc = new Float64Array(4);
+  dericheCausalCoeff(a, bc, sigma);
+
+  // numerator coefficients of the anticausal filter
+  const ba = Float64Array.of(
+    0,
+    bc[1] - a[1] * bc[0],
+    bc[2] - a[2] * bc[0],
+    bc[3] - a[3] * bc[0],
+    -a[4] * bc[0]
+  );
+
+  // impulse response sums
+  const accum_denom = 1.0 + a[1] + a[2] + a[3] + a[4];
+  const sum_causal = (bc[0] + bc[1] + bc[2] + bc[3]) / accum_denom;
+  const sum_anticausal = (ba[1] + ba[2] + ba[3] + ba[4]) / accum_denom;
+
+  // coefficients object
+  return {
+    sigma,
+    negative,
+    a,
+    b_causal: bc,
+    b_anticausal: ba,
+    sum_causal,
+    sum_anticausal
+  };
+}
+
+function dericheCausalCoeff(a_out, b_out, sigma) {
+  const K = 4;
+
+  const alpha = Float64Array.of(
+    0.84, 1.8675,
+    0.84, -1.8675,
+    -0.34015, -0.1299,
+    -0.34015, 0.1299
+  );
+
+  const x1 = Math.exp(-1.783 / sigma);
+  const x2 = Math.exp(-1.723 / sigma);
+  const y1 = 0.6318 / sigma;
+  const y2 = 1.997 / sigma;
+  const beta = Float64Array.of(
+    -x1 * Math.cos( y1), x1 * Math.sin( y1),
+    -x1 * Math.cos(-y1), x1 * Math.sin(-y1),
+    -x2 * Math.cos( y2), x2 * Math.sin( y2),
+    -x2 * Math.cos(-y2), x2 * Math.sin(-y2)
+  );
+
+  const denom = sigma * 2.5066282746310007;
+
+  // initialize b/a = alpha[0] / (1 + beta[0] z^-1)
+  const b = Float64Array.of(alpha[0], alpha[1], 0, 0, 0, 0, 0, 0);
+  const a = Float64Array.of(1, 0, beta[0], beta[1], 0, 0, 0, 0, 0, 0);
+
+  let j, k;
+
+  for (k = 2; k < 8; k += 2) {
+    // add kth term, b/a += alpha[k] / (1 + beta[k] z^-1)
+    b[k]     = beta[k] * b[k - 2] - beta[k + 1] * b[k - 1];
+    b[k + 1] = beta[k] * b[k - 1] + beta[k + 1] * b[k - 2];
+    for (j = k - 2; j > 0; j -= 2) {
+      b[j]     += beta[k] * b[j - 2] - beta[k + 1] * b[j - 1];
+      b[j + 1] += beta[k] * b[j - 1] + beta[k + 1] * b[j - 2];
+    }
+    for (j = 0; j <= k; j += 2) {
+      b[j]     += alpha[k] * a[j]     - alpha[k + 1] * a[j + 1];
+      b[j + 1] += alpha[k] * a[j + 1] + alpha[k + 1] * a[j];
+    }
+
+    a[k + 2] = beta[k] * a[k]     - beta[k + 1] * a[k + 1];
+    a[k + 3] = beta[k] * a[k + 1] + beta[k + 1] * a[k];
+    for (j = k; j > 0; j -= 2) {
+      a[j]     += beta[k] * a[j - 2] - beta[k + 1] * a[j - 1];
+      a[j + 1] += beta[k] * a[j - 1] + beta[k + 1] * a[j - 2];
+    }
+  }
+
+  for (k = 0; k < K; ++k) {
+    j = k << 1;
+    b_out[k] = b[j] / denom;
+    a_out[k + 1] = a[j + 2];
+  }
+}
+
+export function dericheConv2d(cx, cy, grid, [nx, ny]) {
+  // allocate buffers
+  const yc = new Float64Array(Math.max(nx, ny)); // causal
+  const ya = new Float64Array(Math.max(nx, ny)); // anticausal
+  const h = new Float64Array(5);
+  const d = new Float64Array(grid.length);
+
+  // convolve rows
+  for (let row = 0, r0 = 0; row < ny; ++row, r0 += nx) {
+    const dx = d.subarray(r0);
+    dericheConv1d(cx, grid.subarray(r0), nx, 1, yc, ya, h, dx);
+  }
+
+  // convolve columns
+  for (let c0 = 0; c0 < nx; ++c0) {
+    const dy = d.subarray(c0);
+    dericheConv1d(cy, dy, ny, nx, yc, ya, h, dy);
+  }
+
+  return d;
+}
+
+export function dericheConv1d(
+  c, src, N,
+  stride = 1,
+  y_causal = new Float64Array(N),
+  y_anticausal = new Float64Array(N),
+  h = new Float64Array(5),
+  d = y_causal,
+  init = dericheInitZeroPad
+) {
+  const stride_2 = stride * 2;
+  const stride_3 = stride * 3;
+  const stride_4 = stride * 4;
+  const stride_N = stride * N;
+  let i, n;
+
+  // initialize causal filter on the left boundary
+  init(
+    y_causal, src, N, stride,
+    c.b_causal, 3, c.a, 4, c.sum_causal, h, c.sigma
+  );
+
+  // filter the interior samples using a 4th order filter. Implements:
+  // for n = K, ..., N - 1,
+  //   y^+(n) = \sum_{k=0}^{K-1} b^+_k src(n - k)
+  //          - \sum_{k=1}^K a_k y^+(n - k)
+  // variable i tracks the offset to the nth sample of src, it is
+  // updated together with n such that i = stride * n.
+  for (n = 4, i = stride_4; n < N; ++n, i += stride) {
+    y_causal[n] = c.b_causal[0] * src[i]
+      + c.b_causal[1] * src[i - stride]
+      + c.b_causal[2] * src[i - stride_2]
+      + c.b_causal[3] * src[i - stride_3]
+      - c.a[1] * y_causal[n - 1]
+      - c.a[2] * y_causal[n - 2]
+      - c.a[3] * y_causal[n - 3]
+      - c.a[4] * y_causal[n - 4];
+  }
+
+  // initialize the anticausal filter on the right boundary
+  init(
+    y_anticausal, src, N, -stride,
+    c.b_anticausal, 4, c.a, 4, c.sum_anticausal, h, c.sigma
+  );
+
+  // similar to the causal filter above, the following implements:
+  // for n = K, ..., N - 1,
+  //   y^-(n) = \sum_{k=1}^K b^-_k src(N - n - 1 - k)
+  //          - \sum_{k=1}^K a_k y^-(n - k)
+  // variable i is updated such that i = stride * (N - n - 1).
+  for (n = 4, i = stride_N - stride * 5; n < N; ++n, i -= stride) {
+    y_anticausal[n] = c.b_anticausal[1] * src[i + stride]
+      + c.b_anticausal[2] * src[i + stride_2]
+      + c.b_anticausal[3] * src[i + stride_3]
+      + c.b_anticausal[4] * src[i + stride_4]
+      - c.a[1] * y_anticausal[n - 1]
+      - c.a[2] * y_anticausal[n - 2]
+      - c.a[3] * y_anticausal[n - 3]
+      - c.a[4] * y_anticausal[n - 4];
+  }
+
+  // sum the causal and anticausal responses to obtain the final result
+  if (c.negative) {
+    // do not threshold if the input grid includes negatively weighted values
+    for (n = 0, i = 0; n < N; ++n, i += stride) {
+      d[i] = y_causal[n] + y_anticausal[N - n - 1];
+    }
+  } else {
+    // threshold to prevent small negative values due to floating point error
+    for (n = 0, i = 0; n < N; ++n, i += stride) {
+      d[i] = Math.max(0, y_causal[n] + y_anticausal[N - n - 1]);
+    }
+  }
+
+  return d;
+}
+
+export function dericheInitZeroPad(dest, src, N, stride, b, p, a, q, sum, h) {
+  const stride_N = Math.abs(stride) * N;
+  const off = stride < 0 ? stride_N + stride : 0;
+  let i, n, m;
+
+  // compute the first q taps of the impulse response, h_0, ..., h_{q-1}
+  for (n = 0; n < q; ++n) {
+    h[n] = (n <= p) ? b[n] : 0;
+    for (m = 1; m <= q && m <= n; ++m) {
+      h[n] -= a[m] * h[n - m];
+    }
+  }
+
+  // compute dest_m = sum_{n=1}^m h_{m-n} src_n, m = 0, ..., q-1
+  // note: q == 4
+  for (m = 0; m < q; ++m) {
+    for (dest[m] = 0, n = 1; n <= m; ++n) {
+      i = off + stride * n;
+      if (i >= 0 && i < stride_N) {
+        dest[m] += h[m - n] * src[i];
+      }
+    }
+  }
+
+  // dest_m = dest_m + h_{n+m} src_{-n}
+  const cur = src[off];
+  if (cur > 0) {
+    for (m = 0; m < q; ++m) {
+      dest[m] += h[m] * cur;
+    }
+  }
+
+  return;
+}