dsp-collection 0.2.4 → 0.2.6

package/README.md

@@ -1,5 +1,27 @@
-# The source-code.biz JavaScript DSP Collection
+# The JavaScript DSP Collection
 
 A collection of JavaScript modules for digital signal processing (written in TypeScript).
 
 (This package is currently in development)
+
+NPM package: [dsp-collection](https://www.npmjs.com/package/dsp-collection)
+
+## Online test applications
+
+* [Window functions test](https://www.source-code.biz/dsp/js/simpleTests/testWindowFunctions.html)
+* [Signal analysis tests](https://www.source-code.biz/dsp/js/signalAnalysisTests)
+
+## Associated online tools
+
+* [HarmSyn - Harmonic synthesizer](https://www.source-code.biz/harmSyn)
+* [KlattSyn - Klatt formant synthesizer](https://www.source-code.biz/klattSyn)
+* [SinSyn - Sinusoidal synthesizer](https://www.source-code.biz/sinSyn)
+* [SpecFilt - Spectral filter tool](https://www.source-code.biz/specFilt)
+
+## Associated JavaScript packages
+
+* [commons-math-interpolation](https://github.com/chdh/commons-math-interpolation) - Interpolation and regression algorithms
+* [Function curve editor widget](https://www.source-code.biz/snippets/typescript/functionCurveEditor)
+* [Function curve viewer widget](https://www.source-code.biz/snippets/typescript/functionCurveViewer)
+* [WAV file encoder](https://github.com/chdh/wav-file-encoder)
+* [WAV file decoder](https://github.com/chdh/wav-file-decoder)

package/filter/SpecFilt.d.ts

@@ -0,0 +1,10 @@
+export declare const enum FilterType {
+    lowPass = "LP",
+    highPass = "HP",
+    bandPass = "BP",
+    bandStop = "BS"
+}
+export type FilterCurveFunction = (frequency: number) => number;
+export declare function getFilterCurveFunction(filterType: FilterType, filterFreq1: number, filterFreq2: number, smoothingWidth: number): FilterCurveFunction;
+export declare function applyFilterCurveFunction(inAmplitudes: ArrayLike<number>, scalingFactor: number, filterCurveFunction: FilterCurveFunction): Float64Array<ArrayBuffer>;
+export declare function filterSignal(inSamples: ArrayLike<number>, sampleRate: number, filterType: FilterType, filterFreq1: number, filterFreq2: number, smoothingWidth: number): Float64Array;

package/filter/SpecFilt.js

@@ -0,0 +1,98 @@
+import ComplexArray from "../math/ComplexArray.js";
+import * as Fft from "../signal/Fft.js";
+function smoothingFunction(x) {
+    return (Math.sin(x * Math.PI / 2) + 1) / 2;
+}
+export function getFilterCurveFunction(filterType, filterFreq1, filterFreq2, smoothingWidth) {
+    switch (filterType) {
+        case "LP": {
+            return (freq) => {
+                if (freq < filterFreq1 - smoothingWidth) {
+                    return 1;
+                }
+                else if (freq < filterFreq1 + smoothingWidth) {
+                    return smoothingFunction((filterFreq1 - freq) / smoothingWidth);
+                }
+                else {
+                    return 0;
+                }
+            };
+        }
+        case "HP": {
+            return (freq) => {
+                if (freq < filterFreq1 - smoothingWidth) {
+                    return 0;
+                }
+                else if (freq < filterFreq1 + smoothingWidth) {
+                    return smoothingFunction((freq - filterFreq1) / smoothingWidth);
+                }
+                else {
+                    return 1;
+                }
+            };
+        }
+        case "BP": {
+            return (freq) => {
+                if (freq < filterFreq1 - smoothingWidth) {
+                    return 0;
+                }
+                else if (freq < filterFreq1 + smoothingWidth) {
+                    return smoothingFunction((freq - filterFreq1) / smoothingWidth);
+                }
+                else if (freq < filterFreq2 - smoothingWidth) {
+                    return 1;
+                }
+                else if (freq < filterFreq2 + smoothingWidth) {
+                    return smoothingFunction((filterFreq2 - freq) / smoothingWidth);
+                }
+                else {
+                    return 0;
+                }
+            };
+        }
+        case "BS": {
+            return (freq) => {
+                if (freq < filterFreq1 - smoothingWidth) {
+                    return 1;
+                }
+                else if (freq < filterFreq1 + smoothingWidth) {
+                    return smoothingFunction((filterFreq1 - freq) / smoothingWidth);
+                }
+                else if (freq < filterFreq2 - smoothingWidth) {
+                    return 0;
+                }
+                else if (freq < filterFreq2 + smoothingWidth) {
+                    return smoothingFunction((freq - filterFreq2) / smoothingWidth);
+                }
+                else {
+                    return 1;
+                }
+            };
+        }
+        default: {
+            throw new Error("Unsupported filter type.");
+        }
+    }
+}
+export function applyFilterCurveFunction(inAmplitudes, scalingFactor, filterCurveFunction) {
+    const n = inAmplitudes.length;
+    const outAmplitudes = new Float64Array(n);
+    for (let p = 0; p < n; p++) {
+        const frequency = p / scalingFactor;
+        const filterFactor = filterCurveFunction(frequency);
+        outAmplitudes[p] = filterFactor * inAmplitudes[p];
+    }
+    return outAmplitudes;
+}
+export function filterSignal(inSamples, sampleRate, filterType, filterFreq1, filterFreq2, smoothingWidth) {
+    const n = inSamples.length;
+    const inSpectrum = Fft.fftRealSpectrum(inSamples);
+    const inAmplitudes = inSpectrum.getAbsArray();
+    const inPhases = inSpectrum.getArgArray();
+    const filterCurveFunction = getFilterCurveFunction(filterType, filterFreq1, filterFreq2, smoothingWidth);
+    const outAmplitudes = applyFilterCurveFunction(inAmplitudes, n / sampleRate, filterCurveFunction);
+    const outPhases = inPhases;
+    const outSpectrum = ComplexArray.fromPolar(outAmplitudes, outPhases);
+    const outSignal = Fft.iFftRealHalf(outSpectrum, n);
+    return outSignal;
+}

package/math/Complex.d.ts

@@ -1,42 +1,42 @@
-export default class Complex {
-    static readonly I: Complex;
-    static readonly ZERO: Complex;
-    static readonly ONE: Complex;
-    static readonly TWO: Complex;
-    static readonly NaN: Complex;
-    static readonly INFINITY: Complex;
-    readonly re: number;
-    readonly im: number;
-    constructor(re: number, im?: number);
-    toString(): string;
-    toNumber(eps: number): number;
-    isNaN(): boolean;
-    isInfinite(): boolean;
-    isFinite(): boolean;
-    equals(x: Complex): boolean;
-    fuzzyEquals(x: Complex, eps: number): boolean;
-    static expj(arg: number): Complex;
-    static fromPolar(abs: number, arg: number): Complex;
-    abs(): number;
-    arg(): number;
-    conj(): Complex;
-    neg(): Complex;
-    reciprocal(): Complex;
-    exp(): Complex;
-    log(): Complex;
-    sqr(): Complex;
-    sqrt(): Complex;
-    addReal(x: number): Complex;
-    add(x: Complex): Complex;
-    subReal(x: number): Complex;
-    static subFromReal(x: number, y: Complex): Complex;
-    sub(x: Complex): Complex;
-    mulReal(x: number): Complex;
-    mul(x: Complex): Complex;
-    divReal(x: number): Complex;
-    div(x: Complex): Complex;
-    static divFromReal(x: number, y: Complex): Complex;
-    powInt(x: number): Complex;
-    powReal(x: number): Complex;
-    pow(x: Complex): Complex;
-}
+export default class Complex {
+    static readonly I: Complex;
+    static readonly ZERO: Complex;
+    static readonly ONE: Complex;
+    static readonly TWO: Complex;
+    static readonly NaN: Complex;
+    static readonly INFINITY: Complex;
+    readonly re: number;
+    readonly im: number;
+    constructor(re: number, im?: number);
+    toString(): string;
+    toNumber(eps: number): number;
+    isNaN(): boolean;
+    isInfinite(): boolean;
+    isFinite(): boolean;
+    equals(x: Complex): boolean;
+    fuzzyEquals(x: Complex, eps: number): boolean;
+    static expj(arg: number): Complex;
+    static fromPolar(abs: number, arg: number): Complex;
+    abs(): number;
+    arg(): number;
+    conj(): Complex;
+    neg(): Complex;
+    reciprocal(): Complex;
+    exp(): Complex;
+    log(): Complex;
+    sqr(): Complex;
+    sqrt(): Complex;
+    addReal(x: number): Complex;
+    add(x: Complex): Complex;
+    subReal(x: number): Complex;
+    static subFromReal(x: number, y: Complex): Complex;
+    sub(x: Complex): Complex;
+    mulReal(x: number): Complex;
+    mul(x: Complex): Complex;
+    divReal(x: number): Complex;
+    div(x: Complex): Complex;
+    static divFromReal(x: number, y: Complex): Complex;
+    powInt(x: number): Complex;
+    powReal(x: number): Complex;
+    pow(x: Complex): Complex;
+}

package/math/Complex.js

@@ -1,130 +1,130 @@
-import * as MathUtils from "./MathUtils";
-export default class Complex {
-    constructor(re, im = 0) {
-        this.re = re;
-        this.im = im;
-    }
-    toString() {
-        return "(" + this.re + ", " + this.im + ")";
-    }
-    toNumber(eps) {
-        const absIm = Math.abs(this.im);
-        if (!(absIm <= eps || absIm <= Math.abs(this.re) * eps)) {
-            throw new Error("The imaginary part of the complex number is not neglectable small for the conversion to a real number. re=" + this.re + " im=" + this.im + " eps=" + eps + ".");
-        }
-        return this.re;
-    }
-    isNaN() {
-        return isNaN(this.re) || isNaN(this.im);
-    }
-    isInfinite() {
-        return this.re == Infinity || this.re == -Infinity || this.im == Infinity || this.im == -Infinity;
-    }
-    isFinite() {
-        return isFinite(this.re) && isFinite(this.im);
-    }
-    equals(x) {
-        return x && this.re == x.re && this.im == x.im;
-    }
-    fuzzyEquals(x, eps) {
-        return MathUtils.fuzzyEquals(this.re, x.re, eps) && MathUtils.fuzzyEquals(this.im, x.im, eps);
-    }
-    static expj(arg) {
-        return new Complex(Math.cos(arg), Math.sin(arg));
-    }
-    static fromPolar(abs, arg) {
-        return new Complex(abs * Math.cos(arg), abs * Math.sin(arg));
-    }
-    abs() {
-        return Math.hypot(this.re, this.im);
-    }
-    arg() {
-        return Math.atan2(this.im, this.re);
-    }
-    conj() {
-        return new Complex(this.re, -this.im);
-    }
-    neg() {
-        return new Complex(-this.re, -this.im);
-    }
-    reciprocal() {
-        if (this.isNaN()) {
-            return Complex.NaN;
-        }
-        if (this.isInfinite()) {
-            return Complex.ZERO;
-        }
-        const scale = this.re * this.re + this.im * this.im;
-        if (scale == 0) {
-            return Complex.INFINITY;
-        }
-        return new Complex(this.re / scale, -this.im / scale);
-    }
-    exp() {
-        return Complex.fromPolar(Math.exp(this.re), this.im);
-    }
-    log() {
-        return new Complex(Math.log(this.abs()), this.arg());
-    }
-    sqr() {
-        return new Complex(this.re * this.re - this.im * this.im, 2 * this.re * this.im);
-    }
-    sqrt() {
-        if (this.re == 0 && this.im == 0) {
-            return Complex.ZERO;
-        }
-        const m = this.abs();
-        return new Complex(Math.sqrt((m + this.re) / 2), Math.sign(this.im) * Math.sqrt((m - this.re) / 2));
-    }
-    addReal(x) {
-        return new Complex(this.re + x, this.im);
-    }
-    add(x) {
-        return new Complex(this.re + x.re, this.im + x.im);
-    }
-    subReal(x) {
-        return new Complex(this.re - x, this.im);
-    }
-    static subFromReal(x, y) {
-        return new Complex(x - y.re, -y.im);
-    }
-    sub(x) {
-        return new Complex(this.re - x.re, this.im - x.im);
-    }
-    mulReal(x) {
-        return new Complex(this.re * x, this.im * x);
-    }
-    mul(x) {
-        return new Complex(this.re * x.re - this.im * x.im, this.re * x.im + this.im * x.re);
-    }
-    divReal(x) {
-        return new Complex(this.re / x, this.im / x);
-    }
-    div(x) {
-        const m = x.re * x.re + x.im * x.im;
-        return new Complex((this.re * x.re + this.im * x.im) / m, (this.im * x.re - this.re * x.im) / m);
-    }
-    static divFromReal(x, y) {
-        const m = y.re * y.re + y.im * y.im;
-        return new Complex(x * y.re / m, -x * y.im / m);
-    }
-    powInt(x) {
-        if (!Number.isInteger(x)) {
-            throw new Error("powInt() used with non-integer exponent.");
-        }
-        return Complex.fromPolar(Math.pow(this.abs(), x), this.arg() * x);
-    }
-    powReal(x) {
-        return this.log().mulReal(x).exp();
-    }
-    pow(x) {
-        return this.log().mul(x).exp();
-    }
-}
-Complex.I = new Complex(0, 1);
-Complex.ZERO = new Complex(0);
-Complex.ONE = new Complex(1);
-Complex.TWO = new Complex(2);
-Complex.NaN = new Complex(NaN, NaN);
-Complex.INFINITY = new Complex(Infinity, Infinity);
-//# sourceMappingURL=Complex.js.map
+import * as MathUtils from "./MathUtils.js";
+class Complex {
+    constructor(re, im = 0) {
+        this.re = re;
+        this.im = im;
+    }
+    toString() {
+        return "(" + this.re + ", " + this.im + ")";
+    }
+    toNumber(eps) {
+        const absIm = Math.abs(this.im);
+        if (!(absIm <= eps || absIm <= Math.abs(this.re) * eps)) {
+            throw new Error("The imaginary part of the complex number is not neglectable small for the conversion to a real number. re=" + this.re + " im=" + this.im + " eps=" + eps + ".");
+        }
+        return this.re;
+    }
+    isNaN() {
+        return isNaN(this.re) || isNaN(this.im);
+    }
+    isInfinite() {
+        return this.re == Infinity || this.re == -Infinity || this.im == Infinity || this.im == -Infinity;
+    }
+    isFinite() {
+        return isFinite(this.re) && isFinite(this.im);
+    }
+    equals(x) {
+        return x && this.re == x.re && this.im == x.im;
+    }
+    fuzzyEquals(x, eps) {
+        return MathUtils.fuzzyEquals(this.re, x.re, eps) && MathUtils.fuzzyEquals(this.im, x.im, eps);
+    }
+    static expj(arg) {
+        return new Complex(Math.cos(arg), Math.sin(arg));
+    }
+    static fromPolar(abs, arg) {
+        return new Complex(abs * Math.cos(arg), abs * Math.sin(arg));
+    }
+    abs() {
+        return Math.hypot(this.re, this.im);
+    }
+    arg() {
+        return Math.atan2(this.im, this.re);
+    }
+    conj() {
+        return new Complex(this.re, -this.im);
+    }
+    neg() {
+        return new Complex(-this.re, -this.im);
+    }
+    reciprocal() {
+        if (this.isNaN()) {
+            return Complex.NaN;
+        }
+        if (this.isInfinite()) {
+            return Complex.ZERO;
+        }
+        const scale = this.re * this.re + this.im * this.im;
+        if (scale == 0) {
+            return Complex.INFINITY;
+        }
+        return new Complex(this.re / scale, -this.im / scale);
+    }
+    exp() {
+        return Complex.fromPolar(Math.exp(this.re), this.im);
+    }
+    log() {
+        return new Complex(Math.log(this.abs()), this.arg());
+    }
+    sqr() {
+        return new Complex(this.re * this.re - this.im * this.im, 2 * this.re * this.im);
+    }
+    sqrt() {
+        if (this.re == 0 && this.im == 0) {
+            return Complex.ZERO;
+        }
+        const m = this.abs();
+        return new Complex(Math.sqrt((m + this.re) / 2), Math.sign(this.im) * Math.sqrt((m - this.re) / 2));
+    }
+    addReal(x) {
+        return new Complex(this.re + x, this.im);
+    }
+    add(x) {
+        return new Complex(this.re + x.re, this.im + x.im);
+    }
+    subReal(x) {
+        return new Complex(this.re - x, this.im);
+    }
+    static subFromReal(x, y) {
+        return new Complex(x - y.re, -y.im);
+    }
+    sub(x) {
+        return new Complex(this.re - x.re, this.im - x.im);
+    }
+    mulReal(x) {
+        return new Complex(this.re * x, this.im * x);
+    }
+    mul(x) {
+        return new Complex(this.re * x.re - this.im * x.im, this.re * x.im + this.im * x.re);
+    }
+    divReal(x) {
+        return new Complex(this.re / x, this.im / x);
+    }
+    div(x) {
+        const m = x.re * x.re + x.im * x.im;
+        return new Complex((this.re * x.re + this.im * x.im) / m, (this.im * x.re - this.re * x.im) / m);
+    }
+    static divFromReal(x, y) {
+        const m = y.re * y.re + y.im * y.im;
+        return new Complex(x * y.re / m, -x * y.im / m);
+    }
+    powInt(x) {
+        if (!Number.isInteger(x)) {
+            throw new Error("powInt() used with non-integer exponent.");
+        }
+        return Complex.fromPolar(Math.pow(this.abs(), x), this.arg() * x);
+    }
+    powReal(x) {
+        return this.log().mulReal(x).exp();
+    }
+    pow(x) {
+        return this.log().mul(x).exp();
+    }
+}
+Complex.I = new Complex(0, 1);
+Complex.ZERO = new Complex(0);
+Complex.ONE = new Complex(1);
+Complex.TWO = new Complex(2);
+Complex.NaN = new Complex(NaN, NaN);
+Complex.INFINITY = new Complex(Infinity, Infinity);
+export default Complex;

package/math/ComplexArray.d.ts

@@ -1,32 +1,36 @@
-import Complex from "./Complex";
-import MutableComplex from "./MutableComplex";
-export default class ComplexArray {
-    re: Float64Array;
-    im: Float64Array;
-    length: number;
-    constructor(x?: number | Complex[] | Float64Array);
-    private constructByLength;
-    private constructByFloat64Array;
-    private constructByArrayOfComplex;
-    slice(begin?: number, end?: number): ComplexArray;
-    subarray(begin: number, end: number): ComplexArray;
-    set(i: number, c: Complex): void;
-    setReIm(i: number, re: number, im: number): void;
-    static copy1(a1: ComplexArray, i1: number, a2: ComplexArray, i2: number): void;
-    toString(): string;
-    get(i: number): MutableComplex;
-    getAbs(i: number): number;
-    getArg(i: number): number;
-    addRealTo(i: number, x: number): void;
-    addTo(i: number, x: Complex): void;
-    subRealFrom(i: number, x: number): void;
-    subFrom(i: number, x: Complex): void;
-    mulByReal(i: number, x: number): void;
-    mulBy(i: number, x: Complex): void;
-    divByReal(i: number, x: number): void;
-    divBy(i: number, x: Complex): void;
-    mulByArray(a2: ComplexArray): void;
-    mulAllByReal(x: number): void;
-    setMul(i: number, re1: number, im1: number, re2: number, im2: number): void;
-    setDiv(i: number, re1: number, im1: number, re2: number, im2: number): void;
-}
+import Complex from "./Complex.ts";
+import MutableComplex from "./MutableComplex.ts";
+export default class ComplexArray {
+    re: Float64Array;
+    im: Float64Array;
+    length: number;
+    constructor(x?: number | Complex[] | ArrayLike<number>);
+    private constructByLength;
+    private constructByArrayOfComplex;
+    private constructByArrayOfNumber;
+    static fromPolar(absArray: ArrayLike<number>, argArray: ArrayLike<number>): ComplexArray;
+    slice(begin?: number, end?: number): ComplexArray;
+    subarray(begin: number, end: number): ComplexArray;
+    set(i: number, c: Complex): void;
+    setReIm(i: number, re: number, im: number): void;
+    setPolar(i: number, abs: number, arg: number): void;
+    static copy1(a1: ComplexArray, i1: number, a2: ComplexArray, i2: number): void;
+    get(i: number): MutableComplex;
+    getAbs(i: number): number;
+    getArg(i: number): number;
+    toString(): string;
+    getAbsArray(): Float64Array;
+    getArgArray(): Float64Array;
+    addRealTo(i: number, x: number): void;
+    addTo(i: number, x: Complex): void;
+    subRealFrom(i: number, x: number): void;
+    subFrom(i: number, x: Complex): void;
+    mulByReal(i: number, x: number): void;
+    mulBy(i: number, x: Complex): void;
+    divByReal(i: number, x: number): void;
+    divBy(i: number, x: Complex): void;
+    mulByArray(a2: ComplexArray): void;
+    mulAllByReal(x: number): void;
+    setMul(i: number, re1: number, im1: number, re2: number, im2: number): void;
+    setDiv(i: number, re1: number, im1: number, re2: number, im2: number): void;
+}