dsp-collection/signal/Dft.js

A collection of JavaScript modules for digital signal processing (written in TypeScript)

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