dsp-collection 0.2.5 → 0.2.6

package/signal/Autocorrelation.js

@@ -1,54 +1,53 @@
-import * as WindowFunctions from "./WindowFunctions.js";
-import * as ArrayUtils from "../utils/ArrayUtils.js";
-function autocorrelationKernel(x, distance, n) {
-    let sum = 0;
-    for (let i = 0; i < n; i++) {
-        sum += x[i] * x[i + distance];
-    }
-    return sum;
-}
-export function nonPeriodicAutocorrelationSingle(x, distance, compensate) {
-    const n = x.length - distance;
-    let sum = autocorrelationKernel(x, distance, n);
-    if (compensate && n > 0) {
-        sum *= x.length / n;
-    }
-    return sum;
-}
-export function findNonPeriodicAutocorrelationMaximum(x, minDistance, maxDistance, fixedOverlapWidth) {
-    let maxVal = -Infinity;
-    let maxPos = minDistance;
-    for (let distance = minDistance; distance < maxDistance; distance++) {
-        const val = fixedOverlapWidth ?
-            autocorrelationKernel(x, distance, x.length - maxDistance) :
-            nonPeriodicAutocorrelationSingle(x, distance, true);
-        if (val > maxVal) {
-            maxVal = val;
-            maxPos = distance;
-        }
-    }
-    return maxPos;
-}
-export function nonPeriodicAutocorrelation(x, normalize) {
-    const n = x.length;
-    const r = new Float64Array(n);
-    for (let distance = 0; distance < n; distance++) {
-        r[distance] = nonPeriodicAutocorrelationSingle(x, distance, true);
-    }
-    if (normalize && n > 0 && r[0] != 0) {
-        const max = r[0];
-        for (let distance = 0; distance < n; distance++) {
-            r[distance] /= max;
-        }
-    }
-    return r;
-}
-export function windowedNonPeriodicAutocorrelation(x, windowFunction, normalize) {
-    const windowed = WindowFunctions.applyWindow(x, windowFunction);
-    const autoCorr = nonPeriodicAutocorrelation(windowed, normalize);
-    const window = WindowFunctions.getWindowTable(windowFunction, x.length);
-    const windowAutoCorr = nonPeriodicAutocorrelation(window, true);
-    const compensated = ArrayUtils.divide(autoCorr, windowAutoCorr);
-    return compensated;
-}
-//# sourceMappingURL=Autocorrelation.js.map
+import * as WindowFunctions from "./WindowFunctions.js";
+import * as ArrayUtils from "../utils/ArrayUtils.js";
+function autocorrelationKernel(x, distance, n) {
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+        sum += x[i] * x[i + distance];
+    }
+    return sum;
+}
+export function nonPeriodicAutocorrelationSingle(x, distance, compensate) {
+    const n = x.length - distance;
+    let sum = autocorrelationKernel(x, distance, n);
+    if (compensate && n > 0) {
+        sum *= x.length / n;
+    }
+    return sum;
+}
+export function findNonPeriodicAutocorrelationMaximum(x, minDistance, maxDistance, fixedOverlapWidth) {
+    let maxVal = -Infinity;
+    let maxPos = minDistance;
+    for (let distance = minDistance; distance < maxDistance; distance++) {
+        const val = fixedOverlapWidth ?
+            autocorrelationKernel(x, distance, x.length - maxDistance) :
+            nonPeriodicAutocorrelationSingle(x, distance, true);
+        if (val > maxVal) {
+            maxVal = val;
+            maxPos = distance;
+        }
+    }
+    return maxPos;
+}
+export function nonPeriodicAutocorrelation(x, normalize) {
+    const n = x.length;
+    const r = new Float64Array(n);
+    for (let distance = 0; distance < n; distance++) {
+        r[distance] = nonPeriodicAutocorrelationSingle(x, distance, true);
+    }
+    if (normalize && n > 0 && r[0] != 0) {
+        const max = r[0];
+        for (let distance = 0; distance < n; distance++) {
+            r[distance] /= max;
+        }
+    }
+    return r;
+}
+export function windowedNonPeriodicAutocorrelation(x, windowFunction, normalize) {
+    const windowed = WindowFunctions.applyWindow(x, windowFunction);
+    const autoCorr = nonPeriodicAutocorrelation(windowed, normalize);
+    const window = WindowFunctions.getWindowTable(windowFunction, x.length);
+    const windowAutoCorr = nonPeriodicAutocorrelation(window, true);
+    const compensated = ArrayUtils.divide(autoCorr, windowAutoCorr);
+    return compensated;
+}

package/signal/Dft.d.ts

@@ -1,9 +1,9 @@
-import MutableComplex from "../math/MutableComplex.js";
-import ComplexArray from "../math/ComplexArray.js";
-export declare function dftRealSingle(x: ArrayLike<number>, relativeFrequency: number): MutableComplex;
-export declare function dftSingle(x: ComplexArray, relativeFrequency: number, direction: boolean): MutableComplex;
-export declare function dftReal(x: ArrayLike<number>): ComplexArray;
-export declare function dftRealHalf(x: ArrayLike<number>): ComplexArray;
-export declare function dft(x: ComplexArray, direction: boolean): ComplexArray;
-export declare function dftRealSpectrum(x: ArrayLike<number>, inclNyquist?: boolean): ComplexArray;
-export declare function iDftRealSpectrum(x: ComplexArray, len: number): Float64Array;
+import MutableComplex from "../math/MutableComplex.ts";
+import ComplexArray from "../math/ComplexArray.ts";
+export declare function dftRealSingle(x: ArrayLike<number>, relativeFrequency: number): MutableComplex;
+export declare function dftSingle(x: ComplexArray, relativeFrequency: number, direction: boolean): MutableComplex;
+export declare function dftReal(x: ArrayLike<number>): ComplexArray;
+export declare function dftRealHalf(x: ArrayLike<number>): ComplexArray;
+export declare function dft(x: ComplexArray, direction: boolean): ComplexArray;
+export declare function dftRealSpectrum(x: ArrayLike<number>, inclNyquist?: boolean): ComplexArray;
+export declare function iDftRealSpectrum(x: ComplexArray, len: number): Float64Array;

package/signal/Dft.js

@@ -1,88 +1,87 @@
-import Complex from "../math/Complex.js";
-import MutableComplex from "../math/MutableComplex.js";
-import ComplexArray from "../math/ComplexArray.js";
-export function dftRealSingle(x, relativeFrequency) {
-    const n = x.length;
-    if (n == 0) {
-        throw new Error("Input array must not be empty.");
-    }
-    const w = -2 * Math.PI / n * relativeFrequency;
-    const acc = new MutableComplex(0, 0);
-    for (let p = 0; p < n; p++) {
-        const c = Complex.fromPolar(x[p], w * p);
-        acc.addTo(c);
-    }
-    return acc;
-}
-export function dftSingle(x, relativeFrequency, direction) {
-    const n = x.length;
-    if (n == 0) {
-        throw new Error("Input array must not be empty.");
-    }
-    const w = (direction ? -1 : 1) * 2 * Math.PI / n * relativeFrequency;
-    const acc = new MutableComplex(0, 0);
-    for (let p = 0; p < n; p++) {
-        const c = MutableComplex.fromPolar(1, w * p);
-        c.mulBy(x.get(p));
-        acc.addTo(c);
-    }
-    return acc;
-}
-export function dftReal(x) {
-    const n = x.length;
-    const a = new ComplexArray(n);
-    for (let frequency = 0; frequency < n; frequency++) {
-        const c = dftRealSingle(x, frequency);
-        a.set(frequency, c);
-    }
-    return a;
-}
-export function dftRealHalf(x) {
-    const n = Math.ceil(x.length / 2);
-    const a = new ComplexArray(n);
-    for (let frequency = 0; frequency < n; frequency++) {
-        const c = dftRealSingle(x, frequency);
-        a.set(frequency, c);
-    }
-    return a;
-}
-export function dft(x, direction) {
-    const n = x.length;
-    const a = new ComplexArray(n);
-    for (let frequency = 0; frequency < n; frequency++) {
-        const c = dftSingle(x, frequency, direction);
-        a.set(frequency, c);
-    }
-    return a;
-}
-export function dftRealSpectrum(x, inclNyquist = false) {
-    const n = x.length;
-    if (n == 0) {
-        throw new Error("Input array must not be empty.");
-    }
-    const m = (n % 2 == 0 && inclNyquist) ? n / 2 + 1 : Math.ceil(n / 2);
-    const a = new ComplexArray(m);
-    for (let frequency = 0; frequency < m; frequency++) {
-        const c = dftRealSingle(x, frequency);
-        const r = (frequency == 0 || frequency == n / 2) ? 1 / n : 2 / n;
-        c.mulByReal(r);
-        a.set(frequency, c);
-    }
-    return a;
-}
-export function iDftRealSpectrum(x, len) {
-    const a = new Float64Array(len);
-    for (let frequency = 0; frequency < x.length; frequency++) {
-        const c = x.get(frequency);
-        synthesizeSinusoidal(a, frequency, c.abs(), c.arg());
-    }
-    return a;
-}
-function synthesizeSinusoidal(a, frequency, amplitude, phase) {
-    const n = a.length;
-    const w = frequency * 2 * Math.PI / n;
-    for (let p = 0; p < n; p++) {
-        a[p] += amplitude * Math.cos(phase + w * p);
-    }
-}
-//# sourceMappingURL=Dft.js.map
+import Complex from "../math/Complex.js";
+import MutableComplex from "../math/MutableComplex.js";
+import ComplexArray from "../math/ComplexArray.js";
+export function dftRealSingle(x, relativeFrequency) {
+    const n = x.length;
+    if (n == 0) {
+        throw new Error("Input array must not be empty.");
+    }
+    const w = -2 * Math.PI / n * relativeFrequency;
+    const acc = new MutableComplex(0, 0);
+    for (let p = 0; p < n; p++) {
+        const c = Complex.fromPolar(x[p], w * p);
+        acc.addTo(c);
+    }
+    return acc;
+}
+export function dftSingle(x, relativeFrequency, direction) {
+    const n = x.length;
+    if (n == 0) {
+        throw new Error("Input array must not be empty.");
+    }
+    const w = (direction ? -1 : 1) * 2 * Math.PI / n * relativeFrequency;
+    const acc = new MutableComplex(0, 0);
+    for (let p = 0; p < n; p++) {
+        const c = MutableComplex.fromPolar(1, w * p);
+        c.mulBy(x.get(p));
+        acc.addTo(c);
+    }
+    return acc;
+}
+export function dftReal(x) {
+    const n = x.length;
+    const a = new ComplexArray(n);
+    for (let frequency = 0; frequency < n; frequency++) {
+        const c = dftRealSingle(x, frequency);
+        a.set(frequency, c);
+    }
+    return a;
+}
+export function dftRealHalf(x) {
+    const n = Math.ceil(x.length / 2);
+    const a = new ComplexArray(n);
+    for (let frequency = 0; frequency < n; frequency++) {
+        const c = dftRealSingle(x, frequency);
+        a.set(frequency, c);
+    }
+    return a;
+}
+export function dft(x, direction) {
+    const n = x.length;
+    const a = new ComplexArray(n);
+    for (let frequency = 0; frequency < n; frequency++) {
+        const c = dftSingle(x, frequency, direction);
+        a.set(frequency, c);
+    }
+    return a;
+}
+export function dftRealSpectrum(x, inclNyquist = false) {
+    const n = x.length;
+    if (n == 0) {
+        throw new Error("Input array must not be empty.");
+    }
+    const m = (n % 2 == 0 && inclNyquist) ? n / 2 + 1 : Math.ceil(n / 2);
+    const a = new ComplexArray(m);
+    for (let frequency = 0; frequency < m; frequency++) {
+        const c = dftRealSingle(x, frequency);
+        const r = (frequency == 0 || frequency == n / 2) ? 1 / n : 2 / n;
+        c.mulByReal(r);
+        a.set(frequency, c);
+    }
+    return a;
+}
+export function iDftRealSpectrum(x, len) {
+    const a = new Float64Array(len);
+    for (let frequency = 0; frequency < x.length; frequency++) {
+        const c = x.get(frequency);
+        synthesizeSinusoidal(a, frequency, c.abs(), c.arg());
+    }
+    return a;
+}
+function synthesizeSinusoidal(a, frequency, amplitude, phase) {
+    const n = a.length;
+    const w = frequency * 2 * Math.PI / n;
+    for (let p = 0; p < n; p++) {
+        a[p] += amplitude * Math.cos(phase + w * p);
+    }
+}

package/signal/EnvelopeDetection.d.ts

@@ -1 +1 @@
-export declare function generateSignalEnvelope(signal: ArrayLike<number>, windowWidthDc: number, windowWidthEnvelope: number): Float64Array;
+export declare function generateSignalEnvelope(signal: ArrayLike<number>, windowWidthDc: number, windowWidthEnvelope: number): Float64Array;

package/signal/EnvelopeDetection.js

@@ -1,10 +1,9 @@
-import * as MathUtils from "../math/MathUtils.js";
-export function generateSignalEnvelope(signal, windowWidthDc, windowWidthEnvelope) {
-    const a1 = MathUtils.movingAverage(signal, windowWidthDc);
-    for (let i = 0; i < a1.length; i++) {
-        a1[i] = Math.abs(signal[i] - a1[i]);
-    }
-    const a2 = MathUtils.movingAverage(a1, windowWidthEnvelope);
-    return a2;
-}
-//# sourceMappingURL=EnvelopeDetection.js.map
+import * as MathUtils from "../math/MathUtils.js";
+export function generateSignalEnvelope(signal, windowWidthDc, windowWidthEnvelope) {
+    const a1 = MathUtils.simpleMovingAverage(signal, windowWidthDc);
+    for (let i = 0; i < a1.length; i++) {
+        a1[i] = Math.abs(signal[i] - a1[i]);
+    }
+    const a2 = MathUtils.simpleMovingAverage(a1, windowWidthEnvelope);
+    return a2;
+}

package/signal/Fft.d.ts

@@ -1,9 +1,9 @@
-import ComplexArray from "../math/ComplexArray.js";
-export declare function fft(x: ComplexArray, direction?: boolean): ComplexArray;
-export declare function fftReal(x: ArrayLike<number>): ComplexArray;
-export declare function fftRealHalf(x: ArrayLike<number>, inclNyquist?: boolean): ComplexArray;
-export declare function fftRealSpectrum(x: ArrayLike<number>, inclNyquist?: boolean): ComplexArray;
-export declare function fftShift(x: ComplexArray): ComplexArray;
-export declare function iFftRealHalfSimple(x: ComplexArray, len: number, inclNyquist?: boolean): Float64Array;
-export declare function iFftRealHalfOpt(x: ComplexArray, len: number, inclNyquist?: boolean): Float64Array;
-export declare function iFftRealHalf(x: ComplexArray, len: number, inclNyquist?: boolean): Float64Array;
+import ComplexArray from "../math/ComplexArray.ts";
+export declare function fft(x: ComplexArray, direction?: boolean): ComplexArray;
+export declare function fftReal(x: ArrayLike<number>): ComplexArray;
+export declare function fftRealHalf(x: ArrayLike<number>, inclNyquist?: boolean): ComplexArray;
+export declare function fftRealSpectrum(x: ArrayLike<number>, inclNyquist?: boolean): ComplexArray;
+export declare function fftShift(x: ComplexArray): ComplexArray;
+export declare function iFftRealHalfSimple(x: ComplexArray, len: number, inclNyquist?: boolean): Float64Array;
+export declare function iFftRealHalfOpt(x: ComplexArray, len: number, inclNyquist?: boolean): Float64Array;
+export declare function iFftRealHalf(x: ComplexArray, len: number, inclNyquist?: boolean): Float64Array;