@thi.ng/dsp 4.6.16 → 4.6.18

package/aproc.js

@@ -1,33 +1,27 @@
 import { map } from "@thi.ng/transducers/map";
-/**
- * Abstract base class for processors in this package. Provides
- * [`IDeref`](https://docs.thi.ng/umbrella/api/interfaces/IDeref.html) to obtain
- * the processor's current value.
- */
-export class AProc {
-    _val;
-    constructor(_val) {
-        this._val = _val;
-    }
-    deref() {
-        return this._val;
-    }
-    xform() {
-        return map((x) => this.next(x));
-    }
+class AProc {
+  constructor(_val) {
+    this._val = _val;
+  }
+  deref() {
+    return this._val;
+  }
+  xform() {
+    return map((x) => this.next(x));
+  }
 }
-/**
- * Similar to {@link AProc}, but for processors with 2 inputs.
- */
-export class AProc2 {
-    _val;
-    constructor(_val) {
-        this._val = _val;
-    }
-    deref() {
-        return this._val;
-    }
-    xform() {
-        return map(([a, b]) => this.next(a, b));
-    }
+class AProc2 {
+  constructor(_val) {
+    this._val = _val;
+  }
+  deref() {
+    return this._val;
+  }
+  xform() {
+    return map(([a, b]) => this.next(a, b));
+  }
 }
+export {
+  AProc,
+  AProc2
+};

package/biquad.js

@@ -3,190 +3,194 @@ import { PI, SQRT2, SQRT2_2 } from "@thi.ng/math/api";
 import { clamp05 } from "@thi.ng/math/interval";
 import { AProc } from "./aproc.js";
 import { dbMag } from "./convert.js";
-export const biquad = (type, fc, q, gain) => new Biquad(type, fc, q, gain);
-export const biquadLP = (fc, q) => new Biquad("lp", fc, q);
-export const biquadHP = (fc, q) => new Biquad("hp", fc, q);
-export const biquadBP = (fc, q) => new Biquad("bp", fc, q);
-export const biquadNotch = (fc, q) => new Biquad("notch", fc, q);
-export const biquadPeak = (fc, q, gain = 6) => new Biquad("peak", fc, q, gain);
-export const biquadLoShelf = (fc, gain = -6) => new Biquad("loshelf", fc, undefined, gain);
-export const biquadHiShelf = (fc, gain = -6) => new Biquad("hishelf", fc, undefined, gain);
-export class Biquad extends AProc {
-    _type;
-    _freq;
-    _q;
-    _gain;
-    _a0;
-    _a1;
-    _a2;
-    _b1;
-    _b2;
-    _z1;
-    _z2;
-    constructor(_type, _freq, _q = SQRT2_2, _gain = 0) {
-        super(0);
-        this._type = _type;
-        this._freq = _freq;
-        this._q = _q;
-        this._gain = _gain;
-        this.reset();
-        this.calcCoeffs();
-    }
-    reset() {
-        this._z1 = this._z2 = this._val = 0;
-        return this;
-    }
-    next(x) {
-        const out = x * this._a0 + this._z1;
-        this._z1 = x * this._a1 + this._z2 - this._b1 * out;
-        this._z2 = x * this._a2 - this._b2 * out;
-        return (this._val = out);
-    }
-    freq() {
-        return this._freq;
-    }
-    q() {
-        return this._q;
-    }
-    gain() {
-        return this._gain;
-    }
-    set(fc, q, gain) {
-        this._freq = clamp05(fc);
-        this._q = q;
-        this._gain = gain;
-        this.calcCoeffs();
-    }
-    setFreq(fc) {
-        this._freq = clamp05(fc);
-        this.calcCoeffs();
-    }
-    setQ(q) {
-        this._q = q;
-        this.calcCoeffs();
-    }
-    setGain(g) {
-        this._gain = g;
-        this.calcCoeffs();
-    }
-    filterCoeffs() {
-        return {
-            zeroes: [this._a0, this._a1, this._a2],
-            poles: [1, this._b1, this._b2],
-        };
-    }
-    calcCoeffs() {
-        const k = Math.tan(PI * this._freq);
-        const k2 = k * k;
-        const k22 = 2 * (k2 - 1);
-        const kq = k / this._q;
-        const k2kqp1 = 1 + kq + k2;
-        const k2kqm1 = 1 - kq + k2;
-        const ksqrt2 = k * SQRT2;
-        const v = dbMag(Math.abs(this._gain));
-        const kvq = k * (v / this._q);
-        const ksqrt2v = k * Math.sqrt(2 * v);
-        let norm = 1 / k2kqp1;
-        switch (this._type) {
-            case "lp":
-                this._a0 = k2 * norm;
-                this._a1 = 2 * this._a0;
-                this._a2 = this._a0;
-                this._b1 = k22 * norm;
-                this._b2 = k2kqm1 * norm;
-                break;
-            case "hp":
-                this._a0 = norm;
-                this._a1 = -2 * this._a0;
-                this._a2 = this._a0;
-                this._b1 = k22 * norm;
-                this._b2 = k2kqm1 * norm;
-                break;
-            case "bp":
-                this._a0 = kq * norm;
-                this._a1 = 0;
-                this._a2 = -this._a0;
-                this._b1 = k22 * norm;
-                this._b2 = k2kqm1 * norm;
-                break;
-            case "notch":
-                this._a0 = (1 + k2) * norm;
-                this._a1 = k22 * norm;
-                this._a2 = this._a0;
-                this._b1 = this._a1;
-                this._b2 = k2kqm1 * norm;
-                break;
-            case "peak": {
-                const z1 = 1 + kvq + k2;
-                const z2 = 1 - kvq + k2;
-                if (this._gain >= 0) {
-                    this._a0 = z1 * norm;
-                    this._a1 = k22 * norm;
-                    this._a2 = z2 * norm;
-                    this._b1 = this._a1;
-                    this._b2 = k2kqm1 * norm;
-                }
-                else {
-                    norm = 1 / z1;
-                    this._a0 = k2kqp1 * norm;
-                    this._a1 = k22 * norm;
-                    this._a2 = k2kqm1 * norm;
-                    this._b1 = this._a1;
-                    this._b2 = z2 * norm;
-                }
-                break;
-            }
-            case "loshelf": {
-                const z1 = 1 + ksqrt2 + k2;
-                const z2 = 1 - ksqrt2 + k2;
-                const vk2 = v * k2;
-                const y1 = 1 + ksqrt2v + vk2;
-                const y2 = 1 - ksqrt2v + vk2;
-                const vk22 = 2 * (vk2 - 1);
-                if (this._gain >= 0) {
-                    norm = 1 / z1;
-                    this._a0 = y1 * norm;
-                    this._a1 = vk22 * norm;
-                    this._a2 = y2 * norm;
-                    this._b1 = k22 * norm;
-                    this._b2 = z2 * norm;
-                }
-                else {
-                    norm = 1 / y1;
-                    this._a0 = z1 * norm;
-                    this._a1 = k22 * norm;
-                    this._a2 = z2 * norm;
-                    this._b1 = vk22 * norm;
-                    this._b2 = y2 * norm;
-                }
-                break;
-            }
-            case "hishelf": {
-                const z1 = 1 + ksqrt2 + k2;
-                const z2 = 1 - ksqrt2 + k2;
-                const y1 = v + ksqrt2v + k2;
-                const y2 = v - ksqrt2v + k2;
-                const vk2 = 2 * (k2 - v);
-                if (this._gain >= 0) {
-                    norm = 1 / z1;
-                    this._a0 = y1 * norm;
-                    this._a1 = vk2 * norm;
-                    this._a2 = y2 * norm;
-                    this._b1 = k22 * norm;
-                    this._b2 = z2 * norm;
-                }
-                else {
-                    norm = 1 / y1;
-                    this._a0 = z1 * norm;
-                    this._a1 = k22 * norm;
-                    this._a2 = z2 * norm;
-                    this._b1 = vk2 * norm;
-                    this._b2 = y2 * norm;
-                }
-                break;
-            }
-            default:
-                unsupported(`invalid filter type: ${this._type}`);
+const biquad = (type, fc, q, gain) => new Biquad(type, fc, q, gain);
+const biquadLP = (fc, q) => new Biquad("lp", fc, q);
+const biquadHP = (fc, q) => new Biquad("hp", fc, q);
+const biquadBP = (fc, q) => new Biquad("bp", fc, q);
+const biquadNotch = (fc, q) => new Biquad("notch", fc, q);
+const biquadPeak = (fc, q, gain = 6) => new Biquad("peak", fc, q, gain);
+const biquadLoShelf = (fc, gain = -6) => new Biquad("loshelf", fc, void 0, gain);
+const biquadHiShelf = (fc, gain = -6) => new Biquad("hishelf", fc, void 0, gain);
+class Biquad extends AProc {
+  constructor(_type, _freq, _q = SQRT2_2, _gain = 0) {
+    super(0);
+    this._type = _type;
+    this._freq = _freq;
+    this._q = _q;
+    this._gain = _gain;
+    this.reset();
+    this.calcCoeffs();
+  }
+  _a0;
+  _a1;
+  _a2;
+  _b1;
+  _b2;
+  _z1;
+  _z2;
+  reset() {
+    this._z1 = this._z2 = this._val = 0;
+    return this;
+  }
+  next(x) {
+    const out = x * this._a0 + this._z1;
+    this._z1 = x * this._a1 + this._z2 - this._b1 * out;
+    this._z2 = x * this._a2 - this._b2 * out;
+    return this._val = out;
+  }
+  freq() {
+    return this._freq;
+  }
+  q() {
+    return this._q;
+  }
+  gain() {
+    return this._gain;
+  }
+  set(fc, q, gain) {
+    this._freq = clamp05(fc);
+    this._q = q;
+    this._gain = gain;
+    this.calcCoeffs();
+  }
+  setFreq(fc) {
+    this._freq = clamp05(fc);
+    this.calcCoeffs();
+  }
+  setQ(q) {
+    this._q = q;
+    this.calcCoeffs();
+  }
+  setGain(g) {
+    this._gain = g;
+    this.calcCoeffs();
+  }
+  filterCoeffs() {
+    return {
+      zeroes: [this._a0, this._a1, this._a2],
+      poles: [1, this._b1, this._b2]
+    };
+  }
+  calcCoeffs() {
+    const k = Math.tan(PI * this._freq);
+    const k2 = k * k;
+    const k22 = 2 * (k2 - 1);
+    const kq = k / this._q;
+    const k2kqp1 = 1 + kq + k2;
+    const k2kqm1 = 1 - kq + k2;
+    const ksqrt2 = k * SQRT2;
+    const v = dbMag(Math.abs(this._gain));
+    const kvq = k * (v / this._q);
+    const ksqrt2v = k * Math.sqrt(2 * v);
+    let norm = 1 / k2kqp1;
+    switch (this._type) {
+      case "lp":
+        this._a0 = k2 * norm;
+        this._a1 = 2 * this._a0;
+        this._a2 = this._a0;
+        this._b1 = k22 * norm;
+        this._b2 = k2kqm1 * norm;
+        break;
+      case "hp":
+        this._a0 = norm;
+        this._a1 = -2 * this._a0;
+        this._a2 = this._a0;
+        this._b1 = k22 * norm;
+        this._b2 = k2kqm1 * norm;
+        break;
+      case "bp":
+        this._a0 = kq * norm;
+        this._a1 = 0;
+        this._a2 = -this._a0;
+        this._b1 = k22 * norm;
+        this._b2 = k2kqm1 * norm;
+        break;
+      case "notch":
+        this._a0 = (1 + k2) * norm;
+        this._a1 = k22 * norm;
+        this._a2 = this._a0;
+        this._b1 = this._a1;
+        this._b2 = k2kqm1 * norm;
+        break;
+      case "peak": {
+        const z1 = 1 + kvq + k2;
+        const z2 = 1 - kvq + k2;
+        if (this._gain >= 0) {
+          this._a0 = z1 * norm;
+          this._a1 = k22 * norm;
+          this._a2 = z2 * norm;
+          this._b1 = this._a1;
+          this._b2 = k2kqm1 * norm;
+        } else {
+          norm = 1 / z1;
+          this._a0 = k2kqp1 * norm;
+          this._a1 = k22 * norm;
+          this._a2 = k2kqm1 * norm;
+          this._b1 = this._a1;
+          this._b2 = z2 * norm;
+        }
+        break;
+      }
+      case "loshelf": {
+        const z1 = 1 + ksqrt2 + k2;
+        const z2 = 1 - ksqrt2 + k2;
+        const vk2 = v * k2;
+        const y1 = 1 + ksqrt2v + vk2;
+        const y2 = 1 - ksqrt2v + vk2;
+        const vk22 = 2 * (vk2 - 1);
+        if (this._gain >= 0) {
+          norm = 1 / z1;
+          this._a0 = y1 * norm;
+          this._a1 = vk22 * norm;
+          this._a2 = y2 * norm;
+          this._b1 = k22 * norm;
+          this._b2 = z2 * norm;
+        } else {
+          norm = 1 / y1;
+          this._a0 = z1 * norm;
+          this._a1 = k22 * norm;
+          this._a2 = z2 * norm;
+          this._b1 = vk22 * norm;
+          this._b2 = y2 * norm;
+        }
+        break;
+      }
+      case "hishelf": {
+        const z1 = 1 + ksqrt2 + k2;
+        const z2 = 1 - ksqrt2 + k2;
+        const y1 = v + ksqrt2v + k2;
+        const y2 = v - ksqrt2v + k2;
+        const vk2 = 2 * (k2 - v);
+        if (this._gain >= 0) {
+          norm = 1 / z1;
+          this._a0 = y1 * norm;
+          this._a1 = vk2 * norm;
+          this._a2 = y2 * norm;
+          this._b1 = k22 * norm;
+          this._b2 = z2 * norm;
+        } else {
+          norm = 1 / y1;
+          this._a0 = z1 * norm;
+          this._a1 = k22 * norm;
+          this._a2 = z2 * norm;
+          this._b1 = vk2 * norm;
+          this._b2 = y2 * norm;
         }
+        break;
+      }
+      default:
+        unsupported(`invalid filter type: ${this._type}`);
     }
+  }
 }
+export {
+  Biquad,
+  biquad,
+  biquadBP,
+  biquadHP,
+  biquadHiShelf,
+  biquadLP,
+  biquadLoShelf,
+  biquadNotch,
+  biquadPeak
+};

package/bounce.js

@@ -1,18 +1,17 @@
 import { AProc } from "./aproc.js";
-/**
- * Returns a new {@link Bounce} processor, which receives a multi-track tuple
- * input (e.g. as produced by {@link multiplex}) and yields its "bounced down"
- * (aka summed), single channel output.
- */
-export const bounce = () => new Bounce();
-export class Bounce extends AProc {
-    constructor() {
-        super(0);
-    }
-    next(src) {
-        let res = 0;
-        for (let i = src.length; i-- > 0;)
-            res += src[i];
-        return (this._val = res);
-    }
+const bounce = () => new Bounce();
+class Bounce extends AProc {
+  constructor() {
+    super(0);
+  }
+  next(src) {
+    let res = 0;
+    for (let i = src.length; i-- > 0; )
+      res += src[i];
+    return this._val = res;
+  }
 }
+export {
+  Bounce,
+  bounce
+};

package/complex.js

@@ -1,2 +1,5 @@
 import { isNumber } from "@thi.ng/checks/is-number";
-export const isComplex = (buf) => !isNumber(buf[0]);
+const isComplex = (buf) => !isNumber(buf[0]);
+export {
+  isComplex
+};

package/const.js

@@ -1,15 +1,14 @@
 import { AGen } from "./agen.js";
-/**
- * Returns new gen yielding always the same given value `x`.
- *
- * @param x -
- */
-export const constant = (x) => new Const(x);
-export class Const extends AGen {
-    copy() {
-        return new Const(this._val);
-    }
-    next() {
-        return this._val;
-    }
+const constant = (x) => new Const(x);
+class Const extends AGen {
+  copy() {
+    return new Const(this._val);
+  }
+  next() {
+    return this._val;
+  }
 }
+export {
+  Const,
+  constant
+};

package/convert.js

@@ -1,65 +1,19 @@
 import { TAU } from "@thi.ng/math/api";
-/**
- * Returns frequency `f` normalized to sample rate `fs`:
- * `fnorm = f / fs`
- *
- * @param f -
- * @param fs -
- */
-export const normFreq = (f, fs) => f / fs;
-/**
- * Returns frequency `f` in radians, based on sample rate `fs`.
- * I.e. Nyquist freq = PI
- *
- * @param f -
- * @param fs -
- */
-export const freqRad = (f, fs) => (f / fs) * TAU;
-/**
- * Returns period length in milliseconds for given frequency in Hz.
- *
- * @param f -
- */
-export const freqMs = (f) => 1000 / f;
-/**
- * Reverse op of {@link freqRad}.
- *
- * @param rad -
- * @param fs -
- */
-export const radFreq = (rad, fs) => (rad / TAU) * fs;
-/**
- * Returns number of samples for given millisecond period and samle
- * rate.
- *
- * @example
- * ```ts
- * // samples per 20 ms @ 44.1kHz
- * msFrames(20, 44100)
- * // 882
- * ```
- *
- * @param t -
- * @param fs -
- */
-export const msFrames = (t, fs) => t * 0.001 * fs;
-/**
- * Reverse op of {@link msFrames}.
- *
- * @param frames -
- * @param fs -
- */
-export const framesMs = (frames, fs) => (frames / fs) * 1000;
-/**
- * Converts given linear magnitude to dBFS (i.e. `20 * log10(x)`)
- *
- * @param x -
- */
-export const magDb = (x) => (20 * Math.log(x)) / Math.LN10;
-/**
- * Converts given dBFS value to linear magnitude
- * (i.e. `pow(10, x / 20)`)
- *
- * @param x -
- */
-export const dbMag = (x) => 10 ** (x / 20);
+const normFreq = (f, fs) => f / fs;
+const freqRad = (f, fs) => f / fs * TAU;
+const freqMs = (f) => 1e3 / f;
+const radFreq = (rad, fs) => rad / TAU * fs;
+const msFrames = (t, fs) => t * 1e-3 * fs;
+const framesMs = (frames, fs) => frames / fs * 1e3;
+const magDb = (x) => 20 * Math.log(x) / Math.LN10;
+const dbMag = (x) => 10 ** (x / 20);
+export {
+  dbMag,
+  framesMs,
+  freqMs,
+  freqRad,
+  magDb,
+  msFrames,
+  normFreq,
+  radFreq
+};