@thi.ng/dsp 3.0.28 → 4.0.0

package/{gen/pink-noise.js → pink-noise.js}

@@ -1,4 +1,4 @@
-import { SYSTEM } from "@thi.ng/random";
+import { SYSTEM } from "@thi.ng/random/system";
 import { AGen } from "./agen";
 const AMP = [3.8024, 2.9694, 2.597, 3.087, 3.4006];
 const PROB = [0.00198, 0.0128, 0.049, 0.17, 0.682];
@@ -28,6 +28,11 @@ const PROB = [0.00198, 0.0128, 0.049, 0.17, 0.682];
  */
 export const pinkNoise = (gain, rnd, amp, prob) => new PinkNoise(gain, rnd, amp, prob);
 export class PinkNoise extends AGen {
+    _gain;
+    _rnd;
+    _amp;
+    _bins;
+    _psum;
     constructor(_gain = 1, _rnd = SYSTEM, _amp = AMP, prob = PROB) {
         super(0);
         this._gain = _gain;

package/{comp/pipe.d.ts → pipe.d.ts}

@@ -1,4 +1,11 @@
-import type { IGen, IProc } from "../api";
+import type { IGen, IProc } from "./api";
+/**
+ * Higher order generator. Composes a new {@link IGen} from given source gen and
+ * a number of {@link IProc}s (processed in series, like using {@link serial}).
+ *
+ * @param src
+ * @param proc
+ */
 export declare function pipe<A, B>(src: IGen<A>, proc: IProc<A, B>): IGen<B>;
 export declare function pipe<A, B, C>(src: IGen<A>, a: IProc<A, B>, b: IProc<B, C>): IGen<C>;
 export declare function pipe<A, B, C, D>(src: IGen<A>, a: IProc<A, B>, b: IProc<B, C>, c: IProc<C, D>): IGen<D>;

package/{fft/power.d.ts → power.d.ts}

@@ -1,5 +1,5 @@
 import type { NumericArray } from "@thi.ng/api";
-import type { ComplexArray } from "../api";
+import type { ComplexArray } from "./api";
 /**
  * Computes the sum of the given array.
  *

package/{fft/power.js → power.js}

@@ -1,5 +1,5 @@
-import { isNumber } from "@thi.ng/checks";
-import { isComplex } from "../util/complex";
+import { isNumber } from "@thi.ng/checks/is-number";
+import { isComplex } from "./complex";
 /**
  * Computes the sum of the given array.
  *

package/{comp/product.d.ts → product.d.ts}

@@ -1,4 +1,4 @@
-import type { IGen } from "../api";
+import type { IGen } from "./api";
 /**
  * Higher order gen. Returns a {@link MapG2} or {@link MapG3} yielding
  * stepwise (non-accumulated) products of the given {@link IGen}s.

package/{gen/reciprocal.js → reciprocal.js}

@@ -6,6 +6,8 @@ import { AGen } from "./agen";
  */
 export const reciprocal = (step) => new Reciprocal(step);
 export class Reciprocal extends AGen {
+    _step;
+    _n;
     constructor(_step = 1) {
         super(1);
         this._step = _step;

package/serial.d.ts

@@ -0,0 +1,44 @@
+import type { IProc } from "./api";
+import { AProc } from "./aproc";
+/**
+ * Composes the given {@link IProc}s into a single new processor instance. The
+ * returned `IProc` processes the given procs in serial (sequence), i.e. output
+ * from 1st proc is used as input for 2nd etc.
+ *
+ * @remarks
+ * Provides optimized (loop free) versions for 2-4 inputs
+ *
+ * @param a
+ * @param b
+ */
+export declare function serial<A, B, C>(a: IProc<A, B>, b: IProc<B, C>): IProc<A, C>;
+export declare function serial<A, B, C, D>(a: IProc<A, B>, b: IProc<B, C>, c: IProc<C, D>): IProc<A, D>;
+export declare function serial<A, B, C, D, E>(a: IProc<A, B>, b: IProc<B, C>, c: IProc<C, D>, d: IProc<D, E>): IProc<A, E>;
+export declare function serial<A, B, C, D, E>(a: IProc<A, B>, b: IProc<B, C>, c: IProc<C, D>, d: IProc<D, E>, ...xs: IProc<any, any>[]): IProc<A, any>;
+export declare class Serial2<A, B, C> extends AProc<A, C> {
+    protected _a: IProc<A, B>;
+    protected _b: IProc<B, C>;
+    constructor(_a: IProc<A, B>, _b: IProc<B, C>);
+    next(x: A): C;
+}
+export declare class Serial3<A, B, C, D> extends AProc<A, D> {
+    protected _a: IProc<A, B>;
+    protected _b: IProc<B, C>;
+    protected _c: IProc<C, D>;
+    constructor(_a: IProc<A, B>, _b: IProc<B, C>, _c: IProc<C, D>);
+    next(x: A): D;
+}
+export declare class Serial4<A, B, C, D, E> extends AProc<A, E> {
+    protected _a: IProc<A, B>;
+    protected _b: IProc<B, C>;
+    protected _c: IProc<C, D>;
+    protected _d: IProc<D, E>;
+    constructor(_a: IProc<A, B>, _b: IProc<B, C>, _c: IProc<C, D>, _d: IProc<D, E>);
+    next(x: A): E;
+}
+export declare class Serial extends AProc<any, any> {
+    protected _procs: IProc<any, any>[];
+    constructor(_procs: IProc<any, any>[]);
+    next(x: any): any;
+}
+//# sourceMappingURL=serial.d.ts.map

package/{comp/compp.js → serial.js}

@@ -1,18 +1,20 @@
-import { AProc } from "../proc/aproc";
-export function compP(...procs) {
+import { AProc } from "./aproc";
+export function serial(...procs) {
     const [a, b, c, d] = procs;
     switch (procs.length) {
         case 2:
-            return new CompP2(a, b);
+            return new Serial2(a, b);
         case 3:
-            return new CompP3(a, b, c);
+            return new Serial3(a, b, c);
         case 4:
-            return new CompP4(a, b, c, d);
+            return new Serial4(a, b, c, d);
         default:
-            return new CompP(procs);
+            return new Serial(procs);
     }
 }
-export class CompP2 extends AProc {
+export class Serial2 extends AProc {
+    _a;
+    _b;
     constructor(_a, _b) {
         super(null);
         this._a = _a;
@@ -22,7 +24,10 @@ export class CompP2 extends AProc {
         return (this._val = this._b.next(this._a.next(x)));
     }
 }
-export class CompP3 extends AProc {
+export class Serial3 extends AProc {
+    _a;
+    _b;
+    _c;
     constructor(_a, _b, _c) {
         super(null);
         this._a = _a;
@@ -33,7 +38,11 @@ export class CompP3 extends AProc {
         return (this._val = this._c.next(this._b.next(this._a.next(x))));
     }
 }
-export class CompP4 extends AProc {
+export class Serial4 extends AProc {
+    _a;
+    _b;
+    _c;
+    _d;
     constructor(_a, _b, _c, _d) {
         super(null);
         this._a = _a;
@@ -45,7 +54,8 @@ export class CompP4 extends AProc {
         return (this._val = this._d.next(this._c.next(this._b.next(this._a.next(x)))));
     }
 }
-export class CompP extends AProc {
+export class Serial extends AProc {
+    _procs;
     constructor(_procs) {
         super(null);
         this._procs = _procs;

package/{gen/sincos.js → sincos.js}

@@ -1,4 +1,4 @@
-import { TAU } from "@thi.ng/math";
+import { TAU } from "@thi.ng/math/api";
 import { AGen } from "./agen";
 /**
  * Generator of sine & cosine values of given frequency in the form of
@@ -18,6 +18,11 @@ import { AGen } from "./agen";
  * @param amp - amplitude (default: 1)
  */
 export class SinCos extends AGen {
+    _freq;
+    _amp;
+    _f;
+    _s;
+    _c;
     constructor(_freq, _amp = 1) {
         super([0, _amp]);
         this._freq = _freq;

package/{comp/sum.d.ts → sum.d.ts}

@@ -1,4 +1,4 @@
-import type { IGen } from "../api";
+import type { IGen } from "./api";
 /**
  * Higher order gen. Returns a {@link MapG2} or {@link MapG3} yielding
  * stepwise (non-accumulated) sums of given {@link IGen}s. Initializes

package/{proc/svf.d.ts → svf.d.ts}

@@ -1,5 +1,5 @@
 import type { IReset } from "@thi.ng/api";
-import type { SVFType } from "../api";
+import type { SVFType } from "./api";
 import { AProc } from "./aproc";
 export declare const svfLP: (fc: number, q?: number | undefined) => SVF;
 export declare const svfHP: (fc: number, q?: number | undefined) => SVF;

package/{proc/svf.js → svf.js}

@@ -1,4 +1,5 @@
-import { clamp05, PI } from "@thi.ng/math";
+import { PI } from "@thi.ng/math/api";
+import { clamp05 } from "@thi.ng/math/interval";
 import { AProc } from "./aproc";
 export const svfLP = (fc, q) => new SVF("lp", fc, q);
 export const svfHP = (fc, q) => new SVF("hp", fc, q);
@@ -16,6 +17,15 @@ export const svfAllpass = (fc, q) => new SVF("all", fc, q);
  * - https://en.wikipedia.org/wiki/Trapezoidal_rule
  */
 export class SVF extends AProc {
+    _type;
+    _freq;
+    _q;
+    _a1;
+    _a2;
+    _c1;
+    _c2;
+    _g;
+    _k;
     constructor(_type, _freq, _q = 0.5) {
         super(0);
         this._type = _type;

package/{gen/sweep.d.ts → sweep.d.ts}

@@ -24,5 +24,5 @@
  * @param rate
  * @param clamp - true, if clamp at `end` value
  */
-export declare const sweep: (start: number, end: number, steps: number, rate?: number | undefined, clamp?: boolean) => import("..").IGen<number>;
+export declare const sweep: (start: number, end: number, steps: number, rate?: number | undefined, clamp?: boolean) => import("./api").IGen<number>;
 //# sourceMappingURL=sweep.d.ts.map

package/{gen/sweep.js → sweep.js}

@@ -1,4 +1,4 @@
-import { addG } from "../comp/addg";
+import { addG } from "./addg";
 import { curve } from "./curve";
 /**
  * Similar to {@link curve}, but with added accumulation (via

package/{proc/waveshaper.js → waveshaper.js}

@@ -1,4 +1,4 @@
-import { PI } from "@thi.ng/math";
+import { PI } from "@thi.ng/math/api";
 import { AProc } from "./aproc";
 /**
  * Customizable wave shaper for user defined shaping function supporting
@@ -26,6 +26,10 @@ import { AProc } from "./aproc";
  */
 export const waveShaper = (thresh, amp, map) => new WaveShaper(thresh, amp, map);
 export class WaveShaper extends AProc {
+    _coeff;
+    _map;
+    _amp;
+    _autoGain;
     constructor(_coeff = 3, amp = true, _map = waveshapeSigmoid) {
         super(0);
         this._coeff = _coeff;

package/{gen/white-noise.d.ts → white-noise.d.ts}

@@ -1,5 +1,5 @@
 import type { IReset } from "@thi.ng/api";
-import { IRandom } from "@thi.ng/random";
+import type { IRandom } from "@thi.ng/random";
 import { AGen } from "./agen";
 /**
  * White noise gen with customizable gain and

package/{gen/white-noise.js → white-noise.js}

@@ -1,4 +1,4 @@
-import { SYSTEM } from "@thi.ng/random";
+import { SYSTEM } from "@thi.ng/random/system";
 import { AGen } from "./agen";
 /**
  * White noise gen with customizable gain and
@@ -9,6 +9,8 @@ import { AGen } from "./agen";
  */
 export const whiteNoise = (gain, rnd) => new WhiteNoise(gain, rnd);
 export class WhiteNoise extends AGen {
+    _gain;
+    _rnd;
     constructor(_gain = 1, _rnd = SYSTEM) {
         super(0);
         this._gain = _gain;

package/{fft/window.d.ts → window.d.ts}

@@ -1,5 +1,5 @@
 import type { FloatArray, Fn, NumericArray } from "@thi.ng/api";
-import type { WindowFn } from "../api";
+import type { WindowFn } from "./api";
 /**
  * Creates or fills a given buffer with results of window function `fn`.
  * The buffer size MUST be the same as the signal length given to

package/{fft/window.js → window.js}

@@ -1,5 +1,5 @@
-import { isNumber } from "@thi.ng/checks";
-import { PI, TAU } from "@thi.ng/math";
+import { isNumber } from "@thi.ng/checks/is-number";
+import { PI, TAU } from "@thi.ng/math/api";
 // https://en.wikipedia.org/wiki/Window_function
 const PI4 = 4 * PI;
 const PI6 = 6 * PI;

package/comp/compp.d.ts

@@ -1,33 +0,0 @@
-import type { IProc } from "../api";
-import { AProc } from "../proc/aproc";
-export declare function compP<A, B, C>(a: IProc<A, B>, b: IProc<B, C>): IProc<A, C>;
-export declare function compP<A, B, C, D>(a: IProc<A, B>, b: IProc<B, C>, c: IProc<C, D>): IProc<A, D>;
-export declare function compP<A, B, C, D, E>(a: IProc<A, B>, b: IProc<B, C>, c: IProc<C, D>, d: IProc<D, E>): IProc<A, E>;
-export declare function compP<A, B, C, D, E>(a: IProc<A, B>, b: IProc<B, C>, c: IProc<C, D>, d: IProc<D, E>, ...xs: IProc<any, any>[]): IProc<A, any>;
-export declare class CompP2<A, B, C> extends AProc<A, C> {
-    protected _a: IProc<A, B>;
-    protected _b: IProc<B, C>;
-    constructor(_a: IProc<A, B>, _b: IProc<B, C>);
-    next(x: A): C;
-}
-export declare class CompP3<A, B, C, D> extends AProc<A, D> {
-    protected _a: IProc<A, B>;
-    protected _b: IProc<B, C>;
-    protected _c: IProc<C, D>;
-    constructor(_a: IProc<A, B>, _b: IProc<B, C>, _c: IProc<C, D>);
-    next(x: A): D;
-}
-export declare class CompP4<A, B, C, D, E> extends AProc<A, E> {
-    protected _a: IProc<A, B>;
-    protected _b: IProc<B, C>;
-    protected _c: IProc<C, D>;
-    protected _d: IProc<D, E>;
-    constructor(_a: IProc<A, B>, _b: IProc<B, C>, _c: IProc<C, D>, _d: IProc<D, E>);
-    next(x: A): E;
-}
-export declare class CompP extends AProc<any, any> {
-    protected _procs: IProc<any, any>[];
-    constructor(_procs: IProc<any, any>[]);
-    next(x: any): any;
-}
-//# sourceMappingURL=compp.d.ts.map

package/comp/multiplex.d.ts

@@ -1,11 +0,0 @@
-import type { IProc } from "../api";
-import { AProc } from "../proc/aproc";
-export declare function multiplex<T, A, B>(a: IProc<T, A>, b: IProc<T, B>): Multiplex<T, [A, B]>;
-export declare function multiplex<T, A, B, C>(a: IProc<T, A>, b: IProc<T, B>, c: IProc<T, C>): Multiplex<T, [A, B, C]>;
-export declare function multiplex<T, A, B, C, D>(a: IProc<T, A>, b: IProc<T, B>, c: IProc<T, C>, d: IProc<T, D>): Multiplex<T, [A, B, C, D]>;
-export declare class Multiplex<A, B extends any[]> extends AProc<A, B> {
-    protected _procs: IProc<A, any>[];
-    constructor(procs: IProc<A, any>[]);
-    next(x: A): B;
-}
-//# sourceMappingURL=multiplex.d.ts.map