dsp-collection 0.2.5 → 0.2.6

package/signal/Fft.js

@@ -1,276 +1,275 @@
-import ComplexArray from "../math/ComplexArray.js";
-import MutableComplex from "../math/MutableComplex.js";
-import * as MathUtils from "../math/MathUtils.js";
-var cooleyTukeySineTableCache;
-export function fft(x, direction = true) {
-    const n = x.length;
-    if (n <= 1) {
-        return x.slice();
-    }
-    const x2 = direction ? x : swapReIm(x);
-    const x3 = MathUtils.isPowerOf2(n) ? fftCooleyTukey(x2) : fftBluestein(x2);
-    const x4 = direction ? x3 : swapReIm(x3);
-    return x4;
-}
-function fftCooleyTukey(x) {
-    const n = x.length;
-    const sineTable = getCachedCooleyTukeySineTable(n);
-    const a = copyBitReversed(x);
-    applyButterflies(a, sineTable);
-    return a;
-}
-function applyButterflies(a, sineTable) {
-    const temp = new MutableComplex();
-    const n = a.length;
-    const re = a.re;
-    const im = a.im;
-    for (let mMax = 1; mMax < n; mMax *= 2) {
-        const step = mMax * 2;
-        const sinStep = n / step;
-        for (let m = 0; m < mMax; m++) {
-            const wIndex = m * sinStep;
-            const wRe = sineTable.re[wIndex];
-            const wIm = sineTable.im[wIndex];
-            for (let i = m; i < n; i += step) {
-                const j = i + mMax;
-                temp.setMul(re[j], im[j], wRe, wIm);
-                re[j] = re[i] - temp.re;
-                im[j] = im[i] - temp.im;
-                re[i] += temp.re;
-                im[i] += temp.im;
-            }
-        }
-    }
-}
-function copyBitReversed(a1) {
-    const n = a1.length;
-    const a2 = new ComplexArray(n);
-    let i1 = 0;
-    for (let i2 = 0; i2 < n; i2++) {
-        a2.re[i2] = a1.re[i1];
-        a2.im[i2] = a1.im[i1];
-        i1 = incrementBitReversed(i1, n);
-    }
-    return a2;
-}
-function incrementBitReversed(i, n) {
-    let m = n >> 1;
-    let a = i;
-    while (a & m) {
-        a -= m;
-        m >>= 1;
-    }
-    return a | m;
-}
-function fftBluestein(x) {
-    const n = x.length;
-    const m = MathUtils.getNextPowerOf2(2 * n - 3);
-    const sineTable = createSineOfSquareTable(n, 2 * n);
-    const a1 = new ComplexArray(m);
-    for (let i = 0; i < n; i++) {
-        a1.setMul(i, x.re[i], x.im[i], sineTable.re[i], -sineTable.im[i]);
-    }
-    const a2 = new ComplexArray(m);
-    for (let i = 0; i < n; i++) {
-        ComplexArray.copy1(sineTable, i, a2, i);
-    }
-    for (let i = 1; i < n; i++) {
-        ComplexArray.copy1(sineTable, i, a2, m - i);
-    }
-    const a3 = convolve(a1, a2);
-    const a4 = new ComplexArray(n);
-    for (let i = 0; i < n; i++) {
-        a4.setMul(i, a3.re[i], a3.im[i], sineTable.re[i], -sineTable.im[i]);
-    }
-    return a4;
-}
-function convolve(a1, a2) {
-    const n = a1.length;
-    if (a2.length != n) {
-        throw new Error("Array lengths are not equal.");
-    }
-    const a3 = fft(a1);
-    const a4 = fft(a2);
-    a3.mulByArray(a4);
-    const a5 = fft(a3, false);
-    a5.mulAllByReal(1 / n);
-    return a5;
-}
-function getCachedCooleyTukeySineTable(n) {
-    if (!cooleyTukeySineTableCache) {
-        cooleyTukeySineTableCache = new Array(16);
-    }
-    const log2N = MathUtils.floorLog2(n);
-    if (!cooleyTukeySineTableCache[log2N]) {
-        cooleyTukeySineTableCache[log2N] = createCooleyTukeySineTable(n);
-    }
-    return cooleyTukeySineTableCache[log2N];
-}
-function createCooleyTukeySineTable(n) {
-    return createSineTable(n / 2, n, false);
-}
-function createSineTable(tableLength, waveLength, rotationalDirection = true) {
-    const w = 2 * Math.PI / waveLength;
-    const a = new ComplexArray(tableLength);
-    for (let i = 0; i < tableLength; i++) {
-        const t = i * w;
-        a.re[i] = Math.cos(t);
-        a.im[i] = rotationalDirection ? Math.sin(t) : -Math.sin(t);
-    }
-    return a;
-}
-function createSineOfSquareTable(tableLength, waveLength) {
-    const w = 2 * Math.PI / waveLength;
-    const a = new ComplexArray(tableLength);
-    for (let i = 0; i < tableLength; i++) {
-        const t = (i * i) % waveLength * w;
-        a.re[i] = Math.cos(t);
-        a.im[i] = Math.sin(t);
-    }
-    return a;
-}
-function swapReIm(a) {
-    const a2 = new ComplexArray();
-    a2.length = a.length;
-    a2.re = a.im;
-    a2.im = a.re;
-    return a2;
-}
-export function fftReal(x) {
-    return fft(new ComplexArray(x));
-}
-export function fftRealHalf(x, inclNyquist = false) {
-    if (x.length <= 1) {
-        return new ComplexArray(x);
-    }
-    const m = x.length;
-    if (m % 2 != 0) {
-        throw new Error("Input array size is not even.");
-    }
-    const n = m / 2;
-    const a1 = new ComplexArray(n);
-    for (let i = 0; i < n; i++) {
-        a1.re[i] = x[2 * i];
-        a1.im[i] = x[2 * i + 1];
-    }
-    const a2 = fft(a1);
-    const a3 = new ComplexArray(n + (inclNyquist ? 1 : 0));
-    a3.re[0] = a2.re[0] + a2.im[0];
-    a3.im[0] = 0;
-    if (inclNyquist) {
-        a3.re[n] = a2.re[0] - a2.im[0];
-        a3.im[n] = 0;
-    }
-    const temp1 = new MutableComplex();
-    const temp2 = new MutableComplex();
-    const w = Math.PI / n;
-    for (let i = 1; i < n; i++) {
-        const sRe = Math.sin(i * w);
-        const sIm = Math.cos(i * w);
-        temp1.setMul(a2.re[i], a2.im[i], (1 - sRe) / 2, -sIm / 2);
-        temp2.setMul(a2.re[n - i], a2.im[n - i], (1 + sRe) / 2, -sIm / 2);
-        a3.re[i] = temp1.re + temp2.re;
-        a3.im[i] = temp1.im - temp2.im;
-    }
-    return a3;
-}
-export function fftRealSpectrum(x, inclNyquist = false) {
-    const n = x.length;
-    if (n == 0) {
-        throw new Error("Input array must not be empty.");
-    }
-    let a;
-    if (n % 2 == 0) {
-        a = fftRealHalf(x, inclNyquist);
-    }
-    else {
-        const a0 = fftReal(x);
-        a = a0.subarray(0, Math.floor(n / 2) + 1);
-    }
-    for (let i = 0; i < a.length; i++) {
-        const r = (i == 0 || i == n / 2) ? 1 / n : 2 / n;
-        a.mulByReal(i, r);
-    }
-    return a;
-}
-export function fftShift(x) {
-    const n = x.length;
-    const d = Math.floor(n / 2);
-    const a = new ComplexArray(n);
-    for (let p = 0; p < n; p++) {
-        ComplexArray.copy1(x, p, a, (p + d) % n);
-    }
-    return a;
-}
-export function iFftRealHalfSimple(x, len, inclNyquist = false) {
-    if (x.length == 0 || len <= 0) {
-        return new Float64Array(0);
-    }
-    const x2 = createFullSpectrumFromHalfSpectrum(x, len, inclNyquist);
-    const a = fft(x2, false);
-    return a.re;
-}
-function createFullSpectrumFromHalfSpectrum(x, len, inclNyquist) {
-    const x2 = new ComplexArray(len);
-    ComplexArray.copy1(x, 0, x2, 0);
-    if (inclNyquist && len % 2 == 0 && x.length > len / 2) {
-        ComplexArray.copy1(x, len / 2, x2, len / 2);
-    }
-    const n2 = Math.min(x.length - 1, Math.floor((len - 1) / 2));
-    for (let i = 0; i < n2; i++) {
-        const p1 = 1 + i;
-        const p2 = len - 1 - i;
-        x2.re[p2] = x.re[p1];
-        x2.im[p2] = -x.im[p1];
-    }
-    return x2;
-}
-export function iFftRealHalfOpt(x, len, inclNyquist = false) {
-    if (len <= 0) {
-        return new Float64Array(0);
-    }
-    if (len % 2 != 0) {
-        throw new Error("output length is not even.");
-    }
-    const n = len / 2;
-    const a1 = new ComplexArray(n);
-    a1.re[0] = xRe(0);
-    a1.im[0] = xRe(0);
-    if (inclNyquist) {
-        a1.re[0] += xRe(n);
-        a1.im[0] -= xRe(n);
-    }
-    const temp1 = new MutableComplex();
-    const temp2 = new MutableComplex();
-    const w = Math.PI / n;
-    for (let i = 1; i < n; i++) {
-        const sRe = Math.sin(i * w);
-        const sIm = Math.cos(i * w);
-        temp1.setMul(xRe(i), xIm(i), (1 - sRe) / 2, sIm / 2);
-        temp2.setMul(xRe(n - i), xIm(n - i), (1 + sRe) / 2, sIm / 2);
-        a1.re[i] = temp1.re + temp2.re;
-        a1.im[i] = temp1.im - temp2.im;
-    }
-    const a2 = fft(a1, false);
-    const a3 = new Float64Array(2 * n);
-    for (let i = 0; i < n; i++) {
-        a3[2 * i] = a2.re[i];
-        a3[2 * i + 1] = a2.im[i];
-    }
-    return a3;
-    function xRe(i) {
-        return (i < x.length) ? x.re[i] : 0;
-    }
-    function xIm(i) {
-        return (i < x.length) ? x.im[i] : 0;
-    }
-}
-export function iFftRealHalf(x, len, inclNyquist = false) {
-    if (len % 2 == 0) {
-        return iFftRealHalfOpt(x, len, inclNyquist);
-    }
-    else {
-        return iFftRealHalfSimple(x, len, inclNyquist);
-    }
-}
-//# sourceMappingURL=Fft.js.map
+import ComplexArray from "../math/ComplexArray.js";
+import MutableComplex from "../math/MutableComplex.js";
+import * as MathUtils from "../math/MathUtils.js";
+var cooleyTukeySineTableCache;
+export function fft(x, direction = true) {
+    const n = x.length;
+    if (n <= 1) {
+        return x.slice();
+    }
+    const x2 = direction ? x : swapReIm(x);
+    const x3 = MathUtils.isPowerOf2(n) ? fftCooleyTukey(x2) : fftBluestein(x2);
+    const x4 = direction ? x3 : swapReIm(x3);
+    return x4;
+}
+function fftCooleyTukey(x) {
+    const n = x.length;
+    const sineTable = getCachedCooleyTukeySineTable(n);
+    const a = copyBitReversed(x);
+    applyButterflies(a, sineTable);
+    return a;
+}
+function applyButterflies(a, sineTable) {
+    const temp = new MutableComplex();
+    const n = a.length;
+    const re = a.re;
+    const im = a.im;
+    for (let mMax = 1; mMax < n; mMax *= 2) {
+        const step = mMax * 2;
+        const sinStep = n / step;
+        for (let m = 0; m < mMax; m++) {
+            const wIndex = m * sinStep;
+            const wRe = sineTable.re[wIndex];
+            const wIm = sineTable.im[wIndex];
+            for (let i = m; i < n; i += step) {
+                const j = i + mMax;
+                temp.setMul(re[j], im[j], wRe, wIm);
+                re[j] = re[i] - temp.re;
+                im[j] = im[i] - temp.im;
+                re[i] += temp.re;
+                im[i] += temp.im;
+            }
+        }
+    }
+}
+function copyBitReversed(a1) {
+    const n = a1.length;
+    const a2 = new ComplexArray(n);
+    let i1 = 0;
+    for (let i2 = 0; i2 < n; i2++) {
+        a2.re[i2] = a1.re[i1];
+        a2.im[i2] = a1.im[i1];
+        i1 = incrementBitReversed(i1, n);
+    }
+    return a2;
+}
+function incrementBitReversed(i, n) {
+    let m = n >> 1;
+    let a = i;
+    while (a & m) {
+        a -= m;
+        m >>= 1;
+    }
+    return a | m;
+}
+function fftBluestein(x) {
+    const n = x.length;
+    const m = MathUtils.getNextPowerOf2(2 * n - 3);
+    const sineTable = createSineOfSquareTable(n, 2 * n);
+    const a1 = new ComplexArray(m);
+    for (let i = 0; i < n; i++) {
+        a1.setMul(i, x.re[i], x.im[i], sineTable.re[i], -sineTable.im[i]);
+    }
+    const a2 = new ComplexArray(m);
+    for (let i = 0; i < n; i++) {
+        ComplexArray.copy1(sineTable, i, a2, i);
+    }
+    for (let i = 1; i < n; i++) {
+        ComplexArray.copy1(sineTable, i, a2, m - i);
+    }
+    const a3 = convolve(a1, a2);
+    const a4 = new ComplexArray(n);
+    for (let i = 0; i < n; i++) {
+        a4.setMul(i, a3.re[i], a3.im[i], sineTable.re[i], -sineTable.im[i]);
+    }
+    return a4;
+}
+function convolve(a1, a2) {
+    const n = a1.length;
+    if (a2.length != n) {
+        throw new Error("Array lengths are not equal.");
+    }
+    const a3 = fft(a1);
+    const a4 = fft(a2);
+    a3.mulByArray(a4);
+    const a5 = fft(a3, false);
+    a5.mulAllByReal(1 / n);
+    return a5;
+}
+function getCachedCooleyTukeySineTable(n) {
+    if (!cooleyTukeySineTableCache) {
+        cooleyTukeySineTableCache = new Array(16);
+    }
+    const log2N = MathUtils.floorLog2(n);
+    if (!cooleyTukeySineTableCache[log2N]) {
+        cooleyTukeySineTableCache[log2N] = createCooleyTukeySineTable(n);
+    }
+    return cooleyTukeySineTableCache[log2N];
+}
+function createCooleyTukeySineTable(n) {
+    return createSineTable(n / 2, n, false);
+}
+function createSineTable(tableLength, waveLength, rotationalDirection = true) {
+    const w = 2 * Math.PI / waveLength;
+    const a = new ComplexArray(tableLength);
+    for (let i = 0; i < tableLength; i++) {
+        const t = i * w;
+        a.re[i] = Math.cos(t);
+        a.im[i] = rotationalDirection ? Math.sin(t) : -Math.sin(t);
+    }
+    return a;
+}
+function createSineOfSquareTable(tableLength, waveLength) {
+    const w = 2 * Math.PI / waveLength;
+    const a = new ComplexArray(tableLength);
+    for (let i = 0; i < tableLength; i++) {
+        const t = (i * i) % waveLength * w;
+        a.re[i] = Math.cos(t);
+        a.im[i] = Math.sin(t);
+    }
+    return a;
+}
+function swapReIm(a) {
+    const a2 = new ComplexArray();
+    a2.length = a.length;
+    a2.re = a.im;
+    a2.im = a.re;
+    return a2;
+}
+export function fftReal(x) {
+    return fft(new ComplexArray(x));
+}
+export function fftRealHalf(x, inclNyquist = false) {
+    if (x.length <= 1) {
+        return new ComplexArray(x);
+    }
+    const m = x.length;
+    if (m % 2 != 0) {
+        throw new Error("Input array size is not even.");
+    }
+    const n = m / 2;
+    const a1 = new ComplexArray(n);
+    for (let i = 0; i < n; i++) {
+        a1.re[i] = x[2 * i];
+        a1.im[i] = x[2 * i + 1];
+    }
+    const a2 = fft(a1);
+    const a3 = new ComplexArray(n + (inclNyquist ? 1 : 0));
+    a3.re[0] = a2.re[0] + a2.im[0];
+    a3.im[0] = 0;
+    if (inclNyquist) {
+        a3.re[n] = a2.re[0] - a2.im[0];
+        a3.im[n] = 0;
+    }
+    const temp1 = new MutableComplex();
+    const temp2 = new MutableComplex();
+    const w = Math.PI / n;
+    for (let i = 1; i < n; i++) {
+        const sRe = Math.sin(i * w);
+        const sIm = Math.cos(i * w);
+        temp1.setMul(a2.re[i], a2.im[i], (1 - sRe) / 2, -sIm / 2);
+        temp2.setMul(a2.re[n - i], a2.im[n - i], (1 + sRe) / 2, -sIm / 2);
+        a3.re[i] = temp1.re + temp2.re;
+        a3.im[i] = temp1.im - temp2.im;
+    }
+    return a3;
+}
+export function fftRealSpectrum(x, inclNyquist = false) {
+    const n = x.length;
+    if (n == 0) {
+        throw new Error("Input array must not be empty.");
+    }
+    let a;
+    if (n % 2 == 0) {
+        a = fftRealHalf(x, inclNyquist);
+    }
+    else {
+        const a0 = fftReal(x);
+        a = a0.subarray(0, Math.floor(n / 2) + 1);
+    }
+    for (let i = 0; i < a.length; i++) {
+        const r = (i == 0 || i == n / 2) ? 1 / n : 2 / n;
+        a.mulByReal(i, r);
+    }
+    return a;
+}
+export function fftShift(x) {
+    const n = x.length;
+    const d = Math.floor(n / 2);
+    const a = new ComplexArray(n);
+    for (let p = 0; p < n; p++) {
+        ComplexArray.copy1(x, p, a, (p + d) % n);
+    }
+    return a;
+}
+export function iFftRealHalfSimple(x, len, inclNyquist = false) {
+    if (x.length == 0 || len <= 0) {
+        return new Float64Array(0);
+    }
+    const x2 = createFullSpectrumFromHalfSpectrum(x, len, inclNyquist);
+    const a = fft(x2, false);
+    return a.re;
+}
+function createFullSpectrumFromHalfSpectrum(x, len, inclNyquist) {
+    const x2 = new ComplexArray(len);
+    ComplexArray.copy1(x, 0, x2, 0);
+    if (inclNyquist && len % 2 == 0 && x.length > len / 2) {
+        ComplexArray.copy1(x, len / 2, x2, len / 2);
+    }
+    const n2 = Math.min(x.length - 1, Math.floor((len - 1) / 2));
+    for (let i = 0; i < n2; i++) {
+        const p1 = 1 + i;
+        const p2 = len - 1 - i;
+        x2.re[p2] = x.re[p1];
+        x2.im[p2] = -x.im[p1];
+    }
+    return x2;
+}
+export function iFftRealHalfOpt(x, len, inclNyquist = false) {
+    if (len <= 0) {
+        return new Float64Array(0);
+    }
+    if (len % 2 != 0) {
+        throw new Error("output length is not even.");
+    }
+    const n = len / 2;
+    const a1 = new ComplexArray(n);
+    a1.re[0] = xRe(0);
+    a1.im[0] = xRe(0);
+    if (inclNyquist) {
+        a1.re[0] += xRe(n);
+        a1.im[0] -= xRe(n);
+    }
+    const temp1 = new MutableComplex();
+    const temp2 = new MutableComplex();
+    const w = Math.PI / n;
+    for (let i = 1; i < n; i++) {
+        const sRe = Math.sin(i * w);
+        const sIm = Math.cos(i * w);
+        temp1.setMul(xRe(i), xIm(i), (1 - sRe) / 2, sIm / 2);
+        temp2.setMul(xRe(n - i), xIm(n - i), (1 + sRe) / 2, sIm / 2);
+        a1.re[i] = temp1.re + temp2.re;
+        a1.im[i] = temp1.im - temp2.im;
+    }
+    const a2 = fft(a1, false);
+    const a3 = new Float64Array(2 * n);
+    for (let i = 0; i < n; i++) {
+        a3[2 * i] = a2.re[i];
+        a3[2 * i + 1] = a2.im[i];
+    }
+    return a3;
+    function xRe(i) {
+        return (i < x.length) ? x.re[i] : 0;
+    }
+    function xIm(i) {
+        return (i < x.length) ? x.im[i] : 0;
+    }
+}
+export function iFftRealHalf(x, len, inclNyquist = false) {
+    if (len % 2 == 0) {
+        return iFftRealHalfOpt(x, len, inclNyquist);
+    }
+    else {
+        return iFftRealHalfSimple(x, len, inclNyquist);
+    }
+}

package/signal/Goertzel.d.ts

@@ -1,5 +1,5 @@
-import MutableComplex from "../math/MutableComplex.js";
-import ComplexArray from "../math/ComplexArray.js";
-export declare function goertzelSingle(x: ArrayLike<number>, relativeFrequency: number): MutableComplex;
-export declare function goertzel(x: ArrayLike<number>): ComplexArray;
-export declare function goertzelSpectrum(x: ArrayLike<number>, inclNyquist?: boolean): ComplexArray;
+import MutableComplex from "../math/MutableComplex.ts";
+import ComplexArray from "../math/ComplexArray.ts";
+export declare function goertzelSingle(x: ArrayLike<number>, relativeFrequency: number): MutableComplex;
+export declare function goertzel(x: ArrayLike<number>): ComplexArray;
+export declare function goertzelSpectrum(x: ArrayLike<number>, inclNyquist?: boolean): ComplexArray;

package/signal/Goertzel.js

@@ -1,49 +1,48 @@
-import Complex from "../math/Complex.js";
-import MutableComplex from "../math/MutableComplex.js";
-import ComplexArray from "../math/ComplexArray.js";
-export function goertzelSingle(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 c = Complex.expj(w);
-    const cr2 = c.re * 2;
-    let s1 = 0;
-    let s2 = 0;
-    for (let p = 0; p < n; p++) {
-        const s0 = x[p] + cr2 * s1 - s2;
-        s2 = s1;
-        s1 = s0;
-    }
-    return new MutableComplex(c.re * s1 - s2, c.im * s1);
-}
-export function goertzel(x) {
-    const n = x.length;
-    const a = new ComplexArray(n);
-    for (let frequency = 0; frequency < n; frequency++) {
-        const c = goertzelSingle(x, frequency);
-        a.set(frequency, c);
-    }
-    return a;
-}
-export function goertzelSpectrum(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 = goertzelSingle(x, frequency);
-        if (frequency == 0 || frequency == n / 2) {
-            c.divByReal(n);
-        }
-        else {
-            c.mulByReal(2 / n);
-        }
-        a.set(frequency, c);
-    }
-    return a;
-}
-//# sourceMappingURL=Goertzel.js.map
+import Complex from "../math/Complex.js";
+import MutableComplex from "../math/MutableComplex.js";
+import ComplexArray from "../math/ComplexArray.js";
+export function goertzelSingle(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 c = Complex.expj(w);
+    const cr2 = c.re * 2;
+    let s1 = 0;
+    let s2 = 0;
+    for (let p = 0; p < n; p++) {
+        const s0 = x[p] + cr2 * s1 - s2;
+        s2 = s1;
+        s1 = s0;
+    }
+    return new MutableComplex(c.re * s1 - s2, c.im * s1);
+}
+export function goertzel(x) {
+    const n = x.length;
+    const a = new ComplexArray(n);
+    for (let frequency = 0; frequency < n; frequency++) {
+        const c = goertzelSingle(x, frequency);
+        a.set(frequency, c);
+    }
+    return a;
+}
+export function goertzelSpectrum(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 = goertzelSingle(x, frequency);
+        if (frequency == 0 || frequency == n / 2) {
+            c.divByReal(n);
+        }
+        else {
+            c.mulByReal(2 / n);
+        }
+        a.set(frequency, c);
+    }
+    return a;
+}

package/signal/InstFreq.d.ts

@@ -1,8 +1,8 @@
-import * as WindowFunctions from "./WindowFunctions.js";
-export interface InstFreqSingleResult {
-    instFrequency: number;
-    measuringFrequency: number;
-    amplitude: number;
-}
-export declare function instFreqSingle_relWindow(samples: Float64Array | Float32Array, position: number, roughtMeasuringFrequency: number, shiftFactor: number, relWindowWidth: number, windowFunction: WindowFunctions.WindowFunction | undefined): InstFreqSingleResult | undefined;
-export declare function instFreqSingle_maxWindow(samples: Float64Array | Float32Array, position: number, roughtMeasuringFrequency: number, shiftFactor: number, maxWindowWidth: number, windowFunction: WindowFunctions.WindowFunction | undefined): InstFreqSingleResult | undefined;
+import * as WindowFunctions from "./WindowFunctions.ts";
+export interface InstFreqSingleResult {
+    instFrequency: number;
+    measuringFrequency: number;
+    amplitude: number;
+}
+export declare function instFreqSingle_relWindow(samples: Float64Array | Float32Array, position: number, roughtMeasuringFrequency: number, shiftFactor: number, relWindowWidth: number, windowFunction: WindowFunctions.WindowFunction | undefined): InstFreqSingleResult | undefined;
+export declare function instFreqSingle_maxWindow(samples: Float64Array | Float32Array, position: number, roughtMeasuringFrequency: number, shiftFactor: number, maxWindowWidth: number, windowFunction: WindowFunctions.WindowFunction | undefined): InstFreqSingleResult | undefined;