@thi.ng/dsp 4.6.16 → 4.6.18

package/fft.js

@@ -2,355 +2,209 @@ import { isComplex } from "./complex.js";
 import { magDb } from "./convert.js";
 import { invPowerScale, powerScale } from "./power.js";
 import { applyWindow } from "./window.js";
-/**
- * Returns a new tuple of real/img F64 buffers of given size.
- *
- * @param n -
- */
-export const complexArray = (n) => [
-    new Float64Array(n),
-    new Float64Array(n),
+const complexArray = (n) => [
+  new Float64Array(n),
+  new Float64Array(n)
 ];
-/**
- * Creates a deep copy of given {@link ComplexArray}.
- *
- * @param complex -
- */
-export const copyComplex = (complex) => [
-    complex[0].slice(),
-    complex[1].slice(),
+const copyComplex = (complex) => [
+  complex[0].slice(),
+  complex[1].slice()
 ];
-export function conjugate(src, isImg = true) {
-    if (isComplex(src)) {
-        const n = src[0].length;
-        const res = complexArray(n * 2);
-        const [sreal, simg] = src;
-        const [dreal, dimg] = res;
-        dreal.set(sreal);
-        dimg.set(simg);
-        for (let i = 1, j = n * 2 - 1; i < n; i++, j--) {
-            dreal[j] = sreal[i];
-            dimg[j] = -simg[i];
-        }
-        return res;
-    }
-    else {
-        const n = src.length;
-        const dest = new Float64Array(n * 2);
-        dest.set(src);
-        for (let i = 1, j = n * 2 - 1; i < n; i++, j--) {
-            dest[j] = isImg ? -src[i] : src[i];
-        }
-        return dest;
+function conjugate(src, isImg = true) {
+  if (isComplex(src)) {
+    const n = src[0].length;
+    const res = complexArray(n * 2);
+    const [sreal, simg] = src;
+    const [dreal, dimg] = res;
+    dreal.set(sreal);
+    dimg.set(simg);
+    for (let i = 1, j = n * 2 - 1; i < n; i++, j--) {
+      dreal[j] = sreal[i];
+      dimg[j] = -simg[i];
     }
+    return res;
+  } else {
+    const n = src.length;
+    const dest = new Float64Array(n * 2);
+    dest.set(src);
+    for (let i = 1, j = n * 2 - 1; i < n; i++, j--) {
+      dest[j] = isImg ? -src[i] : src[i];
+    }
+    return dest;
+  }
 }
 const swapR = (real, n) => {
-    const n2 = n >> 1;
-    let ii;
-    let jj;
-    let k;
-    let t;
-    for (let i = 1, j = 1; i < n; i++) {
-        if (i < j) {
-            ii = i - 1;
-            jj = j - 1;
-            t = real[jj];
-            real[jj] = real[ii];
-            real[ii] = t;
-        }
-        k = n2;
-        while (k < j) {
-            j -= k;
-            k >>= 1;
-        }
-        j += k;
-    }
+  const n2 = n >> 1;
+  let ii;
+  let jj;
+  let k;
+  let t;
+  for (let i = 1, j = 1; i < n; i++) {
+    if (i < j) {
+      ii = i - 1;
+      jj = j - 1;
+      t = real[jj];
+      real[jj] = real[ii];
+      real[ii] = t;
+    }
+    k = n2;
+    while (k < j) {
+      j -= k;
+      k >>= 1;
+    }
+    j += k;
+  }
 };
 const swapRI = (real, img, n) => {
-    const n2 = n >> 1;
-    let ii;
-    let jj;
-    let k;
-    let t;
-    for (let i = 1, j = 1; i < n; i++) {
-        if (i < j) {
-            ii = i - 1;
-            jj = j - 1;
-            t = real[jj];
-            real[jj] = real[ii];
-            real[ii] = t;
-            t = img[jj];
-            img[jj] = img[ii];
-            img[ii] = t;
-        }
-        k = n2;
-        while (k < j) {
-            j -= k;
-            k >>= 1;
-        }
-        j += k;
-    }
+  const n2 = n >> 1;
+  let ii;
+  let jj;
+  let k;
+  let t;
+  for (let i = 1, j = 1; i < n; i++) {
+    if (i < j) {
+      ii = i - 1;
+      jj = j - 1;
+      t = real[jj];
+      real[jj] = real[ii];
+      real[ii] = t;
+      t = img[jj];
+      img[jj] = img[ii];
+      img[ii] = t;
+    }
+    k = n2;
+    while (k < j) {
+      j -= k;
+      k >>= 1;
+    }
+    j += k;
+  }
 };
 const transform = (real, img, n) => {
-    let step = 1;
-    let prevStep;
-    let i, j, ii, ip;
-    let tr, ti;
-    let ur, ui;
-    let wr, wi;
-    let t;
-    for (let b = Math.ceil(Math.log2(n)); b-- > 0;) {
-        prevStep = step;
-        step <<= 1;
-        ur = 1;
-        ui = 0;
-        t = Math.PI / prevStep;
-        wr = Math.cos(t);
-        wi = -Math.sin(t);
-        for (j = 1; j <= prevStep; j++) {
-            for (i = j; i <= n; i += step) {
-                ip = i + prevStep - 1;
-                ii = i - 1;
-                tr = real[ip] * ur - img[ip] * ui;
-                ti = real[ip] * ui + img[ip] * ur;
-                real[ip] = real[ii] - tr;
-                img[ip] = img[ii] - ti;
-                real[ii] += tr;
-                img[ii] += ti;
-            }
-            t = ur;
-            ur = t * wr - ui * wi;
-            ui = t * wi + ui * wr;
-        }
-    }
+  let step = 1;
+  let prevStep;
+  let i, j, ii, ip;
+  let tr, ti;
+  let ur, ui;
+  let wr, wi;
+  let t;
+  for (let b = Math.ceil(Math.log2(n)); b-- > 0; ) {
+    prevStep = step;
+    step <<= 1;
+    ur = 1;
+    ui = 0;
+    t = Math.PI / prevStep;
+    wr = Math.cos(t);
+    wi = -Math.sin(t);
+    for (j = 1; j <= prevStep; j++) {
+      for (i = j; i <= n; i += step) {
+        ip = i + prevStep - 1;
+        ii = i - 1;
+        tr = real[ip] * ur - img[ip] * ui;
+        ti = real[ip] * ui + img[ip] * ur;
+        real[ip] = real[ii] - tr;
+        img[ip] = img[ii] - ti;
+        real[ii] += tr;
+        img[ii] += ti;
+      }
+      t = ur;
+      ur = t * wr - ui * wi;
+      ui = t * wi + ui * wr;
+    }
+  }
 };
-/**
- * Computes in-place forward FFT for given real/imaginary component
- * buffers (each MUST be pow2 length), optionally with windowing.
- *
- * @remarks
- * If `window` is given, the `real` array will be pre-multiplied with
- * the `window`.
- *
- * No result scaling / normalization is performed. Use
- * {@link normalizeFFT} for that purpose.
- *
- * - https://www.earlevel.com/main/2002/08/31/a-gentle-introduction-to-the-fft/
- * - https://www.earlevel.com/main/2019/04/30/waveutils-updated/
- * - https://betterexplained.com/articles/an-interactive-guide-to-the-fourier-transform/
- * - http://toxi.co.uk/p5/fftDebug/fft4amit.pde
- *
- * @param complex -
- * @param window -
- */
-export const fft = (complex, window) => {
-    let real, img;
-    if (isComplex(complex)) {
-        real = complex[0];
-        img = complex[1];
-    }
-    else {
-        real = complex;
-    }
-    if (window) {
-        applyWindow(real, window);
-    }
-    const n = real.length;
-    if (img) {
-        swapRI(real, img, n);
-    }
-    else {
-        swapR(real, n);
-        img = new Float64Array(n);
-    }
-    transform(real, img, n);
-    return [real, img];
+const fft = (complex, window) => {
+  let real, img;
+  if (isComplex(complex)) {
+    real = complex[0];
+    img = complex[1];
+  } else {
+    real = complex;
+  }
+  if (window) {
+    applyWindow(real, window);
+  }
+  const n = real.length;
+  if (img) {
+    swapRI(real, img, n);
+  } else {
+    swapR(real, n);
+    img = new Float64Array(n);
+  }
+  transform(real, img, n);
+  return [real, img];
 };
-/**
- * Inverse FFT via computing forward transform with swapped real/imaginary
- * components. Expects denormalized inputs (i.e. the same as the result of
- * {@link fft}).
- *
- * @remarks
- *
- * - https://www.dsprelated.com/showarticle/800.php (method #3)
- *
- * @param complex -
- */
-export const ifft = (src) => {
-    let complex = isComplex(src)
-        ? src
-        : [new Float64Array(src.length), src];
-    fft([complex[1], complex[0]]);
-    return scaleFFT(complex, 1 / complex[0].length);
+const ifft = (src) => {
+  let complex = isComplex(src) ? src : [new Float64Array(src.length), src];
+  fft([complex[1], complex[0]]);
+  return scaleFFT(complex, 1 / complex[0].length);
 };
-export const scaleFFT = (complex, scale) => {
-    const [real, img] = complex;
-    const n = real.length;
-    for (let i = 0; i < n; i++) {
-        real[i] *= scale;
-        img[i] *= scale;
-    }
-    return [real, img];
+const scaleFFT = (complex, scale) => {
+  const [real, img] = complex;
+  const n = real.length;
+  for (let i = 0; i < n; i++) {
+    real[i] *= scale;
+    img[i] *= scale;
+  }
+  return [real, img];
 };
-/**
- * Normalizes the complex FFT array by scaling each complex bin value with given
- * scale factor (or, if given as array, the scale factor derived from these
- * window function samples).
- *
- * @remarks
- * By default assumes a rectangular window and the resulting scale factor of 2 /
- * N.
- *
- * References:
- * - https://holometer.fnal.gov/GH_FFT.pdf
- *
- * @param complex -
- * @param window -
- */
-export const normalizeFFT = (complex, window = 2 / complex[0].length) => scaleFFT(complex, powerScale(window, 2));
-/**
- * Inverse operation of {@link normalizeFFT}. De-normalizes the complex FFT
- * array by scaling each complex bin value with given scale factor (or, if given
- * as array, the scale factor derived from these window function samples).
- *
- * @remarks
- * By default assumes a rectangular window and the resulting scale factor of N /
- * 2.
- *
- * References:
- * - https://holometer.fnal.gov/GH_FFT.pdf
- *
- * @param complex -
- * @param window -
- */
-export const denormalizeFFT = (complex, window = complex[0].length / 2) => scaleFFT(complex, invPowerScale(window, 2));
-/**
- * Computes the magnitude of each FFT bin and if less than given `eps`
- * threshold, sets that bin to zero. Returns input FFT array.
- *
- * @remarks
- * It's recommended to apply this function prior computing
- * {@link spectrumPhase}. The `eps` value might have to be adjusted and should
- * be approx. `max(spectrumMag(fft))/10000`.
- *
- * References:
- * - https://www.gaussianwaves.com/2015/11/interpreting-fft-results-obtaining-magnitude-and-phase-information/
- *
- * @param complex -
- * @param eps -
- */
-export const thresholdFFT = (complex, eps = 1e-12) => {
-    const [real, img] = complex;
-    for (let i = 0, n = real.length; i < n; i++) {
-        if (Math.hypot(real[i], img[i]) < eps) {
-            real[i] = img[i] = 0;
-        }
-    }
-    return complex;
+const normalizeFFT = (complex, window = 2 / complex[0].length) => scaleFFT(complex, powerScale(window, 2));
+const denormalizeFFT = (complex, window = complex[0].length / 2) => scaleFFT(complex, invPowerScale(window, 2));
+const thresholdFFT = (complex, eps = 1e-12) => {
+  const [real, img] = complex;
+  for (let i = 0, n = real.length; i < n; i++) {
+    if (Math.hypot(real[i], img[i]) < eps) {
+      real[i] = img[i] = 0;
+    }
+  }
+  return complex;
 };
-/**
- * Computes magnitude spectrum for given FFT: y(i) = abs(c(i)). By default only
- * the first N/2 values are returned.
- *
- * @param complex - FFT result
- * @param n - bin count
- * @param out - result array
- */
-export const spectrumMag = (complex, n = complex[0].length / 2, out = []) => {
-    const [real, img] = complex;
-    for (let i = 0; i < n; i++) {
-        out[i] = Math.hypot(real[i], img[i]);
-    }
-    return out;
+const spectrumMag = (complex, n = complex[0].length / 2, out = []) => {
+  const [real, img] = complex;
+  for (let i = 0; i < n; i++) {
+    out[i] = Math.hypot(real[i], img[i]);
+  }
+  return out;
 };
-/**
- * Computes power spectrum (optionally as dBFS) for the given FFT result arrays
- * (length = N) and optional `window`. Writes result to `out` or a new array.
- *
- * @remarks
- * If `window` is given (scale factor or array), it will be used as (if number)
- * or to compute the scaling factor (if array) for each FFT bin's value. The
- * default (`window=1`) is the equivalent to a rectangular window (i.e. a
- * no-op). If windowing was used to compute the FFT, the same should be provided
- * to this function for correct results.
- *
- * **IMPORTANT:** If the FFT result has already been normalized using
- * {@link normalizeFFT}, the scaling factor (`window` arg) MUST be set 1.0.
- *
- * By default only the first N/2 values are returned. If `db` is true, the
- * spectrum values are converted to dBFS.
- *
- * - https://holometer.fnal.gov/GH_FFT.pdf
- * - https://dsp.stackexchange.com/a/32080
- * - https://dsp.stackexchange.com/a/14935
- * - https://www.kvraudio.com/forum/viewtopic.php?t=276092
- *
- * @param complex -
- * @param db -
- * @param window -
- * @param n -
- * @param out -
- */
-export const spectrumPow = (complex, db = false, window = 2 / complex[0].length, n = complex[0].length / 2, out = []) => {
-    const [real, img] = complex;
-    const scale = powerScale(window, 2);
-    for (let i = 0; i < n; i++) {
-        const p = real[i] ** 2 + img[i] ** 2;
-        out[i] = db ? magDb(Math.sqrt(p) * scale) : p * scale;
-    }
-    return out;
+const spectrumPow = (complex, db = false, window = 2 / complex[0].length, n = complex[0].length / 2, out = []) => {
+  const [real, img] = complex;
+  const scale = powerScale(window, 2);
+  for (let i = 0; i < n; i++) {
+    const p = real[i] ** 2 + img[i] ** 2;
+    out[i] = db ? magDb(Math.sqrt(p) * scale) : p * scale;
+  }
+  return out;
 };
-/**
- * Computes phase spectrum for given FFT and writes results to `out`. By default
- * only the first N/2 values are returned.
- *
- * @remarks
- * Consider applying {@link thresholdFFT} prior to computing the phase spectrum
- * to avoid exploding floating point error magnitudes.
- *
- * @param complex - FFT result
- * @param n - bin count
- * @param out - result array
- */
-export const spectrumPhase = (complex, n = complex[0].length / 2, out = []) => {
-    const [real, img] = complex;
-    for (let i = 0; i < n; i++) {
-        out[i] = Math.atan2(img[i], real[i]);
-    }
-    return out;
+const spectrumPhase = (complex, n = complex[0].length / 2, out = []) => {
+  const [real, img] = complex;
+  for (let i = 0; i < n; i++) {
+    out[i] = Math.atan2(img[i], real[i]);
+  }
+  return out;
 };
-/**
- * Returns FFT bin index for given frequency, sample rate and window
- * size. See {@link binFreq} for reverse op.
- *
- * @param f - frequency
- * @param fs - sample rate
- * @param n - window size
- */
-export const freqBin = (f, fs, n) => ((f * n) / fs) | 0;
-/**
- * Returns frequency for given FFT bin index, sample rate and window
- * size. See {@link freqBin} for reverse op.
- *
- * @param bin - bin
- * @param fs - sample rate
- * @param n - window size
- */
-export const binFreq = (bin, fs, n) => (bin * fs) / n;
-/**
- * Returns array of bin center frequencies for given FFT window size and sample
- * rate. By default only the first N/2+1 values are returned (`m` and including
- * 0Hz).
- *
- * @param n - window size
- * @param fs - sample rate
- * @param m - number of result values
- */
-export const fftFreq = (n, fs, m = n / 2) => {
-    const res = new Float64Array(m);
-    for (let i = 0; i <= m; i++) {
-        res[i] = binFreq(i, fs, n);
-    }
-    return res;
+const freqBin = (f, fs, n) => f * n / fs | 0;
+const binFreq = (bin, fs, n) => bin * fs / n;
+const fftFreq = (n, fs, m = n / 2) => {
+  const res = new Float64Array(m);
+  for (let i = 0; i <= m; i++) {
+    res[i] = binFreq(i, fs, n);
+  }
+  return res;
+};
+export {
+  binFreq,
+  complexArray,
+  conjugate,
+  copyComplex,
+  denormalizeFFT,
+  fft,
+  fftFreq,
+  freqBin,
+  ifft,
+  normalizeFFT,
+  scaleFFT,
+  spectrumMag,
+  spectrumPhase,
+  spectrumPow,
+  thresholdFFT
 };

package/filter-delay.js

@@ -1,30 +1,26 @@
 import { clamp01 } from "@thi.ng/math/interval";
 import { Delay } from "./delay.js";
-/**
- * Extension of {@link feedbackDelay} with an additional filter/proc applied to
- * the feedback itself (e.g. a low pass filter).
- *
- * @param n - delay length
- * @param filter - IProc applied to feedback
- * @param feedback - feedback factor (default: 0.5)
- */
-export const filterFeedbackDelay = (n, filter, feedback) => new FilterFeedbackDelay(n, filter, feedback);
-export class FilterFeedbackDelay extends Delay {
-    filter;
-    _feedback;
-    constructor(n, filter, _feedback = 0.5) {
-        super(n, 0);
-        this.filter = filter;
-        this._feedback = _feedback;
-        this.setFeedback(_feedback);
-    }
-    next(x) {
-        return super.next(x + this.filter.next(this._buf[this._rpos] * this._feedback));
-    }
-    feedback() {
-        return this._feedback;
-    }
-    setFeedback(feedback) {
-        this._feedback = clamp01(feedback);
-    }
+const filterFeedbackDelay = (n, filter, feedback) => new FilterFeedbackDelay(n, filter, feedback);
+class FilterFeedbackDelay extends Delay {
+  constructor(n, filter, _feedback = 0.5) {
+    super(n, 0);
+    this.filter = filter;
+    this._feedback = _feedback;
+    this.setFeedback(_feedback);
+  }
+  next(x) {
+    return super.next(
+      x + this.filter.next(this._buf[this._rpos] * this._feedback)
+    );
+  }
+  feedback() {
+    return this._feedback;
+  }
+  setFeedback(feedback) {
+    this._feedback = clamp01(feedback);
+  }
 }
+export {
+  FilterFeedbackDelay,
+  filterFeedbackDelay
+};

package/filter-response.js

@@ -2,39 +2,28 @@ import { cossin } from "@thi.ng/math/angle";
 import { TAU } from "@thi.ng/math/api";
 import { magDb } from "./convert.js";
 import { line } from "./line.js";
-/**
- * Returns filter response for given filter coefficients at normalized
- * frequency `f`. If `db` is true (default), the magnitude in the
- * returned object will be in dBFS.
- *
- * References:
- *
- * - https://www.earlevel.com/main/2016/12/01/evaluating-filter-frequency-response/
- * - https://www.earlevel.com/main/2016/12/08/filter-frequency-response-grapher/
- * - https://github.com/mohayonao/freqr
- *
- * @param zeroes -
- * @param poles -
- * @param freq -
- * @param db -
- */
-export const filterResponseRaw = (zeroes, poles, freq, db = true) => {
-    const w0 = TAU * freq;
-    const [cp, sp] = convolve(poles, w0);
-    const [cz, sz] = convolve(zeroes, w0);
-    const mag = Math.sqrt((cz * cz + sz * sz) / (cp * cp + sp * sp));
-    const phase = Math.atan2(sp, cp) - Math.atan2(sz, cz);
-    return { freq, phase, mag: db ? magDb(mag) : mag };
+const filterResponseRaw = (zeroes, poles, freq, db = true) => {
+  const w0 = TAU * freq;
+  const [cp, sp] = convolve(poles, w0);
+  const [cz, sz] = convolve(zeroes, w0);
+  const mag = Math.sqrt((cz * cz + sz * sz) / (cp * cp + sp * sp));
+  const phase = Math.atan2(sp, cp) - Math.atan2(sz, cz);
+  return { freq, phase, mag: db ? magDb(mag) : mag };
 };
-export const filterResponse = (coeffs, freq, db) => filterResponseRaw(coeffs.zeroes, coeffs.poles, freq, db);
-export const freqRange = (fstart, fend, num) => line(fstart, fend, num - 1).take(num);
+const filterResponse = (coeffs, freq, db) => filterResponseRaw(coeffs.zeroes, coeffs.poles, freq, db);
+const freqRange = (fstart, fend, num) => line(fstart, fend, num - 1).take(num);
 const convolve = (coeffs, w0) => {
-    let c = 0;
-    let s = 0;
-    for (let i = coeffs.length; i-- > 0;) {
-        const k = cossin(w0 * i, coeffs[i]);
-        c += k[0];
-        s += k[1];
-    }
-    return [c, s];
+  let c = 0;
+  let s = 0;
+  for (let i = coeffs.length; i-- > 0; ) {
+    const k = cossin(w0 * i, coeffs[i]);
+    c += k[0];
+    s += k[1];
+  }
+  return [c, s];
+};
+export {
+  filterResponse,
+  filterResponseRaw,
+  freqRange
 };