@thi.ng/dsp 4.6.16 → 4.6.18

package/cosine.js

@@ -1,51 +1,46 @@
 import { TAU } from "@thi.ng/math/api";
 import { AGen } from "./agen.js";
-/**
- * Approximated cosine generator using given normalized `freq` and `amp`
- * (default: 1).
- *
- * @param freq -
- * @param amp -
- */
-export const cosine = (freq, amp) => new Cosine(freq, amp);
-export class Cosine extends AGen {
-    _freq;
-    _amp;
-    _cos;
-    _nxt;
-    constructor(_freq, _amp = 1) {
-        super(0);
-        this._freq = _freq;
-        this._amp = _amp;
-        this.calcCoeffs();
-    }
-    reset() {
-        this.calcCoeffs();
-        return this;
-    }
-    next() {
-        const t = this._nxt * this._cos - this._val;
-        this._val = this._nxt;
-        this._nxt = t;
-        return this._val;
-    }
-    freq() {
-        return this._freq;
-    }
-    setFreq(freq) {
-        this._freq = freq;
-        this.calcCoeffs();
-    }
-    amp() {
-        return this._amp;
-    }
-    setAmp(amp) {
-        this._amp = amp;
-        this.calcCoeffs();
-    }
-    calcCoeffs() {
-        this._nxt = this._amp;
-        this._cos = Math.cos(this._freq * TAU) * 2;
-        this._val = this._cos * this._amp * 0.5;
-    }
+const cosine = (freq, amp) => new Cosine(freq, amp);
+class Cosine extends AGen {
+  constructor(_freq, _amp = 1) {
+    super(0);
+    this._freq = _freq;
+    this._amp = _amp;
+    this.calcCoeffs();
+  }
+  _cos;
+  _nxt;
+  reset() {
+    this.calcCoeffs();
+    return this;
+  }
+  next() {
+    const t = this._nxt * this._cos - this._val;
+    this._val = this._nxt;
+    this._nxt = t;
+    return this._val;
+  }
+  freq() {
+    return this._freq;
+  }
+  setFreq(freq) {
+    this._freq = freq;
+    this.calcCoeffs();
+  }
+  amp() {
+    return this._amp;
+  }
+  setAmp(amp) {
+    this._amp = amp;
+    this.calcCoeffs();
+  }
+  calcCoeffs() {
+    this._nxt = this._amp;
+    this._cos = Math.cos(this._freq * TAU) * 2;
+    this._val = this._cos * this._amp * 0.5;
+  }
 }
+export {
+  Cosine,
+  cosine
+};

package/curve.js

@@ -1,43 +1,14 @@
 import { MAdd } from "./madd.js";
-/**
- * Returns new {@link MAdd} gen, producing an exponential curve (with
- * adjustable curvature) between `start` and `end` values over `num`
- * steps. This is the exponential equivalent of {@link line}.
- *
- * @remarks
- * Unless `skipFirst` is true (default: false), the `end` value is only
- * reached at `num + 1` steps. Unless `clampEnd` is true (default:
- * false), the curve will NOT stop at `end` but continue indefinitely if
- * more values are requested from the generator.
- *
- * The curvature can be controlled via the logarithmic `rate` param.
- * Recommended range [0.0001 - 10000] (curved -> linear). Default: 0.1
- *
- * Also see {@link madd}.
- *
- * @example
- * ```ts
- * curve(-1, 1, 5, 0.1).take(7)
- * // [
- * //   -1,
- * //   -0.04228753006664476,
- * //   0.4786567612639258,
- * //   0.7620225554764573,
- * //   0.9161583712747458,
- * //   1.0000000000000002,  // target
- * //   1.0456053557111122
- * // ]
- * ```
- *
- * @param start - start value
- * @param end - end value
- * @param num - num steps
- * @param rate - curvature control
- * @param skipFirst - true to skip start value (default: false)
- * @param clampEnd - true to clamp curve at end value (default: false)
- */
-export const curve = (start, end, num, rate = 0.1, skipFirst = false, clampEnd = false) => {
-    const c = Math.exp(-Math.log((Math.abs(end - start) + rate) / rate) / num);
-    const offset = (start < end ? end + rate : end - rate) * (1 - c);
-    return new MAdd(c, skipFirst ? offset + start * c : start, offset, clampEnd ? end : undefined);
+const curve = (start, end, num, rate = 0.1, skipFirst = false, clampEnd = false) => {
+  const c = Math.exp(-Math.log((Math.abs(end - start) + rate) / rate) / num);
+  const offset = (start < end ? end + rate : end - rate) * (1 - c);
+  return new MAdd(
+    c,
+    skipFirst ? offset + start * c : start,
+    offset,
+    clampEnd ? end : void 0
+  );
+};
+export {
+  curve
 };

package/dcblock.js

@@ -1,12 +1,11 @@
 import { OnePole } from "./onepole.js";
-/**
- * One-pole DC blocker based on {@link OnePole}.
- *
- * @param freq -
- */
-export const dcBlock = (freq) => new DCBlock("lp", freq);
-export class DCBlock extends OnePole {
-    next(x) {
-        return x - super.next(x);
-    }
+const dcBlock = (freq) => new DCBlock("lp", freq);
+class DCBlock extends OnePole {
+  next(x) {
+    return x - super.next(x);
+  }
 }
+export {
+  DCBlock,
+  dcBlock
+};

package/delay.js

@@ -2,117 +2,106 @@ import { isFunction } from "@thi.ng/checks/is-function";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { wrap } from "@thi.ng/math/interval";
 import { AProc } from "./aproc.js";
-/**
- * Delay line of length `n` for numeric values.
- *
- * @param n -
- */
-export const delay = (n) => new Delay(n, 0);
-/**
- * Delay line of length `n` for arbitrary typed values.
- *
- * @param n -
- */
-export const delayT = (n, off) => new Delay(n, off);
-/**
- * Ring buffer / delay line for arbitrary values w/ support for tapping
- * at any delay time (within configured buffer size).
- */
-export class Delay extends AProc {
-    _empty;
-    _buf;
-    _rpos;
-    _wpos;
-    /**
-     * Constructs new delay line of size `n` and initializes all
-     * elements to `empty`. If the latter is a function, the buffer will
-     * be initialized with the results of that function (called for each
-     * element).
-     *
-     * @param n -
-     * @param _empty -
-     */
-    constructor(n, _empty) {
-        super(isFunction(_empty) ? _empty() : _empty);
-        this._empty = _empty;
-        if (n < 1)
-            illegalArgs("delay size must be >= 1");
-        n >>>= 0;
-        this._wpos = n - 1;
-        this._rpos = 0;
-        this._buf = new Array(n);
-        this.clear();
+const delay = (n) => new Delay(n, 0);
+const delayT = (n, off) => new Delay(n, off);
+class Delay extends AProc {
+  /**
+   * Constructs new delay line of size `n` and initializes all
+   * elements to `empty`. If the latter is a function, the buffer will
+   * be initialized with the results of that function (called for each
+   * element).
+   *
+   * @param n -
+   * @param _empty -
+   */
+  constructor(n, _empty) {
+    super(isFunction(_empty) ? _empty() : _empty);
+    this._empty = _empty;
+    if (n < 1)
+      illegalArgs("delay size must be >= 1");
+    n >>>= 0;
+    this._wpos = n - 1;
+    this._rpos = 0;
+    this._buf = new Array(n);
+    this.clear();
+  }
+  _buf;
+  _rpos;
+  _wpos;
+  get length() {
+    return this._buf.length;
+  }
+  clear() {
+    const { _buf, _empty } = this;
+    if (isFunction(_empty)) {
+      for (let i = _buf.length; i-- > 0; ) {
+        this._buf[i] = _empty();
+      }
+    } else {
+      this._buf.fill(_empty);
     }
-    get length() {
-        return this._buf.length;
-    }
-    clear() {
-        const { _buf, _empty } = this;
-        if (isFunction(_empty)) {
-            for (let i = _buf.length; i-- > 0;) {
-                this._buf[i] = _empty();
-            }
-        }
-        else {
-            this._buf.fill(_empty);
-        }
-    }
-    copy() {
-        return new Delay(this._buf.length, this._empty);
-    }
-    /**
-     * Alias for {@link Delay.clear}
-     */
-    reset() {
-        this.clear();
-        return this;
-    }
-    /**
-     * Returns the delayed value at current read position (i.e. `n`
-     * samples behind current write pos, where `n` is the length of this
-     * delay line).
-     */
-    deref() {
-        return this._buf[this._rpos];
-    }
-    /**
-     * Reads value at `t` relative to current write position. `t` should
-     * be in `(-∞..0)` interval. E.g. `tap(-1)` returns the second
-     * most recent value written.
-     *
-     * @param t -
-     */
-    tap(t) {
-        return this._buf[wrap((t | 0) + this._wpos, 0, this._buf.length - 1)];
-    }
-    /**
-     * Takes an array of offsets relative to current write position,
-     * calls {@link Delay.tap} for each, writes results to `out` and
-     * returns it.
-     */
-    multiTap(t, out = []) {
-        for (let i = t.length; i-- > 0;) {
-            out[i] = this.tap(t[i]);
-        }
-        return out;
-    }
-    /**
-     * Progresses read & write pos, stores new value and returns delayed value.
-     *
-     * @param x -
-     */
-    next(x) {
-        this.step();
-        this._buf[this._wpos] = x;
-        return (this._val = this._buf[this._rpos]);
-    }
-    /**
-     * Moves read & write cursors one step forward. Useful for skipping
-     * elements and/or to create gaps in the delay line.
-     */
-    step() {
-        const n = this._buf.length;
-        ++this._wpos >= n && (this._wpos -= n);
-        ++this._rpos >= n && (this._rpos -= n);
+  }
+  copy() {
+    return new Delay(this._buf.length, this._empty);
+  }
+  /**
+   * Alias for {@link Delay.clear}
+   */
+  reset() {
+    this.clear();
+    return this;
+  }
+  /**
+   * Returns the delayed value at current read position (i.e. `n`
+   * samples behind current write pos, where `n` is the length of this
+   * delay line).
+   */
+  deref() {
+    return this._buf[this._rpos];
+  }
+  /**
+   * Reads value at `t` relative to current write position. `t` should
+   * be in `(-∞..0)` interval. E.g. `tap(-1)` returns the second
+   * most recent value written.
+   *
+   * @param t -
+   */
+  tap(t) {
+    return this._buf[wrap((t | 0) + this._wpos, 0, this._buf.length - 1)];
+  }
+  /**
+   * Takes an array of offsets relative to current write position,
+   * calls {@link Delay.tap} for each, writes results to `out` and
+   * returns it.
+   */
+  multiTap(t, out = []) {
+    for (let i = t.length; i-- > 0; ) {
+      out[i] = this.tap(t[i]);
     }
+    return out;
+  }
+  /**
+   * Progresses read & write pos, stores new value and returns delayed value.
+   *
+   * @param x -
+   */
+  next(x) {
+    this.step();
+    this._buf[this._wpos] = x;
+    return this._val = this._buf[this._rpos];
+  }
+  /**
+   * Moves read & write cursors one step forward. Useful for skipping
+   * elements and/or to create gaps in the delay line.
+   */
+  step() {
+    const n = this._buf.length;
+    ++this._wpos >= n && (this._wpos -= n);
+    ++this._rpos >= n && (this._rpos -= n);
+  }
 }
+export {
+  Delay,
+  delay,
+  delayT
+};

package/feedback-delay.js

@@ -1,33 +1,26 @@
 import { clamp01 } from "@thi.ng/math/interval";
 import { Delay } from "./delay.js";
-/**
- * Extension of {@link Delay} which adds sum delayed value multiplied
- * with `feedback` for each new input.
- *
- * @remarks
- * Also see {@link filterFeedbackDelay} for filtered version.
- *
- * @param n - delay length
- * @param feedback - feedback factor (default: 0.5)
- */
-export const feedbackDelay = (n, feedback) => new FeedbackDelay(n, feedback);
-export class FeedbackDelay extends Delay {
-    _feedback;
-    constructor(n, _feedback = 0.5) {
-        super(n, 0);
-        this._feedback = _feedback;
-        this.setFeedback(_feedback);
-    }
-    copy() {
-        return new FeedbackDelay(this._buf.length, this._feedback);
-    }
-    next(x) {
-        return super.next(x + this._buf[this._rpos] * this._feedback);
-    }
-    feedback() {
-        return this._feedback;
-    }
-    setFeedback(feedback) {
-        this._feedback = clamp01(feedback);
-    }
+const feedbackDelay = (n, feedback) => new FeedbackDelay(n, feedback);
+class FeedbackDelay extends Delay {
+  constructor(n, _feedback = 0.5) {
+    super(n, 0);
+    this._feedback = _feedback;
+    this.setFeedback(_feedback);
+  }
+  copy() {
+    return new FeedbackDelay(this._buf.length, this._feedback);
+  }
+  next(x) {
+    return super.next(x + this._buf[this._rpos] * this._feedback);
+  }
+  feedback() {
+    return this._feedback;
+  }
+  setFeedback(feedback) {
+    this._feedback = clamp01(feedback);
+  }
 }
+export {
+  FeedbackDelay,
+  feedbackDelay
+};