dsp-collection 0.2.4 → 0.2.6

package/signal/PitchDetectionHarm.d.ts

@@ -1,26 +1,26 @@
-import * as WindowFunctions from "./WindowFunctions";
-export interface HarmonicAmplitudeEvaluationParms {
-    amplitudeCompressionExponent: number;
-    harmonicsDeclineRate: number;
-    harmonicsDeclineExponent: number;
-}
-export interface HarmonicSumParms extends HarmonicAmplitudeEvaluationParms {
-    fCutoff: number;
-    relWindowWidth: number;
-    windowFunction: WindowFunctions.WindowFunction | undefined;
-}
-export interface HarmonicInstSumParms extends HarmonicSumParms {
-    shiftFactor: number;
-    peakWidthFactor: number;
-}
-export declare function getDefaultHarmonicSumParms(): HarmonicSumParms;
-export declare function getDefaultHarmonicInstSumParms(): HarmonicInstSumParms;
-export declare function harmonicSum(samples: Float64Array, sampleRate: number, position: number, f0: number, parms?: HarmonicSumParms): number;
-export declare function harmonicInstSum(samples: Float64Array, sampleRate: number, position: number, f0: number, parms?: HarmonicInstSumParms): number;
-export declare function evaluateHarmonicAmplitude(amplitude: number, harmonic: number, parms: HarmonicAmplitudeEvaluationParms): number;
-export declare function findPitchSalienceFunctionArgMax(salienceFunction: (f0: number) => number, f0Min: number, f0Max: number, { scanFactor, relTolerance, absTolerance }?: {
-    scanFactor?: number | undefined;
-    relTolerance?: number | undefined;
-    absTolerance?: number | undefined;
-}): number;
-export declare function estimatePitch_harmonicSum(samples: Float64Array, sampleRate: number, position: number, f0Min?: number, f0Max?: number, parms?: HarmonicSumParms): number;
+import * as WindowFunctions from "./WindowFunctions.ts";
+export interface HarmonicAmplitudeEvaluationParms {
+    amplitudeCompressionExponent: number;
+    harmonicsDeclineRate: number;
+    harmonicsDeclineExponent: number;
+}
+export interface HarmonicSumParms extends HarmonicAmplitudeEvaluationParms {
+    fCutoff: number;
+    relWindowWidth: number;
+    windowFunction: WindowFunctions.WindowFunction | undefined;
+}
+export interface HarmonicInstSumParms extends HarmonicSumParms {
+    shiftFactor: number;
+    peakWidthFactor: number;
+}
+export declare function getDefaultHarmonicSumParms(): HarmonicSumParms;
+export declare function getDefaultHarmonicInstSumParms(): HarmonicInstSumParms;
+export declare function harmonicSum(samples: Float64Array | Float32Array, sampleRate: number, position: number, f0: number, parms?: HarmonicSumParms): number;
+export declare function harmonicInstSum(samples: Float64Array | Float32Array, sampleRate: number, position: number, f0: number, parms?: HarmonicInstSumParms): number;
+export declare function evaluateHarmonicAmplitude(amplitude: number, harmonic: number, parms: HarmonicAmplitudeEvaluationParms): number;
+export declare function findPitchSalienceFunctionArgMax(salienceFunction: (f0: number) => number, f0Min: number, f0Max: number, { scanFactor, relTolerance, absTolerance }?: {
+    scanFactor?: number | undefined;
+    relTolerance?: number | undefined;
+    absTolerance?: number | undefined;
+}): number;
+export declare function estimatePitch_harmonicSum(samples: Float64Array | Float32Array, sampleRate: number, position: number, f0Min?: number, f0Max?: number, parms?: HarmonicSumParms): number;

package/signal/PitchDetectionHarm.js

@@ -1,69 +1,68 @@
-import * as MathUtils from "../math/MathUtils";
-import * as NumApprox from "../math/NumApprox";
-import * as WindowFunctions from "./WindowFunctions";
-import * as AdaptiveStft from "./AdaptiveStft";
-import * as InstFreq from "./InstFreq";
-export function getDefaultHarmonicSumParms() {
-    return {
-        amplitudeCompressionExponent: 0.5,
-        harmonicsDeclineRate: 0.2,
-        harmonicsDeclineExponent: 0,
-        fCutoff: 5000,
-        relWindowWidth: 16,
-        windowFunction: WindowFunctions.getFunctionbyId("hann", { tableCacheCostLimit: 1 })
-    };
-}
-export function getDefaultHarmonicInstSumParms() {
-    return Object.assign({}, getDefaultHarmonicSumParms(), { shiftFactor: 0.25, peakWidthFactor: 0.2 });
-}
-export function harmonicSum(samples, sampleRate, position, f0, parms = getDefaultHarmonicSumParms()) {
-    const n = Math.floor(parms.fCutoff / f0);
-    const a = AdaptiveStft.getHarmonicAmplitudes(samples, position * sampleRate, f0 / sampleRate, n, parms.relWindowWidth, parms.windowFunction);
-    if (!a) {
-        return NaN;
-    }
-    return evaluateHarmonicAmplitudes(a, parms);
-}
-export function harmonicInstSum(samples, sampleRate, position, f0, parms = getDefaultHarmonicInstSumParms()) {
-    const peakWidth = f0 * parms.peakWidthFactor / sampleRate;
-    const n = Math.floor(parms.fCutoff / f0);
-    let sum = 0;
-    let count = 0;
-    for (let harmonic = 1; harmonic <= n; harmonic++) {
-        const f = harmonic * f0 / sampleRate;
-        const r = InstFreq.instFreqSingle_relWindow(samples, position * sampleRate, f, parms.shiftFactor, parms.relWindowWidth * harmonic, parms.windowFunction);
-        if (r) {
-            const absDelta = Math.abs(r.measuringFrequency - r.instFrequency);
-            const a = r.amplitude * Math.max(0, 1 - (2 * absDelta) / peakWidth);
-            sum += evaluateHarmonicAmplitude(a, harmonic, parms);
-            count++;
-        }
-    }
-    return (count > 0) ? sum : NaN;
-}
-export function evaluateHarmonicAmplitude(amplitude, harmonic, parms) {
-    const attenuation = MathUtils.hyperbolicDecline(harmonic - 1, parms.harmonicsDeclineRate, parms.harmonicsDeclineExponent);
-    return amplitude ** parms.amplitudeCompressionExponent * attenuation;
-}
-function evaluateHarmonicAmplitudes(amplitudes, parms) {
-    let sum = 0;
-    for (let harmonic = 1; harmonic <= amplitudes.length; harmonic++) {
-        sum += evaluateHarmonicAmplitude(amplitudes[harmonic - 1], harmonic, parms);
-    }
-    return sum;
-}
-export function findPitchSalienceFunctionArgMax(salienceFunction, f0Min, f0Max, { scanFactor = 1.005, relTolerance = 1E-3, absTolerance = 0.05 } = {}) {
-    const f1 = NumApprox.argMax_scanGeom(salienceFunction, f0Min, f0Max, scanFactor);
-    if (!isFinite(f1)) {
-        return NaN;
-    }
-    const f1Lo = Math.max(f1 / scanFactor, f0Min);
-    const f1Hi = Math.min(f1 * scanFactor, f0Max);
-    const tolerance = Math.min(f1 * relTolerance, absTolerance);
-    return NumApprox.argMax_goldenSectionSearch(salienceFunction, f1Lo, f1Hi, tolerance);
-}
-export function estimatePitch_harmonicSum(samples, sampleRate, position, f0Min = 75, f0Max = 900, parms = getDefaultHarmonicSumParms()) {
-    const salienceFunction = (f0) => harmonicSum(samples, sampleRate, position, f0, parms);
-    return findPitchSalienceFunctionArgMax(salienceFunction, f0Min, f0Max);
-}
-//# sourceMappingURL=PitchDetectionHarm.js.map
+import * as MathUtils from "../math/MathUtils.js";
+import * as NumApprox from "../math/NumApprox.js";
+import * as WindowFunctions from "./WindowFunctions.js";
+import * as AdaptiveStft from "./AdaptiveStft.js";
+import * as InstFreq from "./InstFreq.js";
+export function getDefaultHarmonicSumParms() {
+    return {
+        amplitudeCompressionExponent: 0.5,
+        harmonicsDeclineRate: 0.2,
+        harmonicsDeclineExponent: 0,
+        fCutoff: 5000,
+        relWindowWidth: 16,
+        windowFunction: WindowFunctions.getFunctionbyId("hann", { tableCacheCostLimit: 1 })
+    };
+}
+export function getDefaultHarmonicInstSumParms() {
+    return Object.assign(Object.assign({}, getDefaultHarmonicSumParms()), { shiftFactor: 0.25, peakWidthFactor: 0.2 });
+}
+export function harmonicSum(samples, sampleRate, position, f0, parms = getDefaultHarmonicSumParms()) {
+    const n = Math.floor(parms.fCutoff / f0);
+    const a = AdaptiveStft.getHarmonicAmplitudes(samples, position * sampleRate, f0 / sampleRate, n, parms.relWindowWidth, parms.windowFunction);
+    if (!a) {
+        return NaN;
+    }
+    return evaluateHarmonicAmplitudes(a, parms);
+}
+export function harmonicInstSum(samples, sampleRate, position, f0, parms = getDefaultHarmonicInstSumParms()) {
+    const peakWidth = f0 * parms.peakWidthFactor / sampleRate;
+    const n = Math.floor(parms.fCutoff / f0);
+    let sum = 0;
+    let count = 0;
+    for (let harmonic = 1; harmonic <= n; harmonic++) {
+        const f = harmonic * f0 / sampleRate;
+        const r = InstFreq.instFreqSingle_relWindow(samples, position * sampleRate, f, parms.shiftFactor, parms.relWindowWidth * harmonic, parms.windowFunction);
+        if (r) {
+            const absDelta = Math.abs(r.measuringFrequency - r.instFrequency);
+            const a = r.amplitude * Math.max(0, 1 - (2 * absDelta) / peakWidth);
+            sum += evaluateHarmonicAmplitude(a, harmonic, parms);
+            count++;
+        }
+    }
+    return (count > 0) ? sum : NaN;
+}
+export function evaluateHarmonicAmplitude(amplitude, harmonic, parms) {
+    const attenuation = MathUtils.hyperbolicDecline(harmonic - 1, parms.harmonicsDeclineRate, parms.harmonicsDeclineExponent);
+    return amplitude ** parms.amplitudeCompressionExponent * attenuation;
+}
+function evaluateHarmonicAmplitudes(amplitudes, parms) {
+    let sum = 0;
+    for (let harmonic = 1; harmonic <= amplitudes.length; harmonic++) {
+        sum += evaluateHarmonicAmplitude(amplitudes[harmonic - 1], harmonic, parms);
+    }
+    return sum;
+}
+export function findPitchSalienceFunctionArgMax(salienceFunction, f0Min, f0Max, { scanFactor = 1.005, relTolerance = 1E-3, absTolerance = 0.05 } = {}) {
+    const f1 = NumApprox.argMax_scanGeom(salienceFunction, f0Min, f0Max, scanFactor);
+    if (!isFinite(f1)) {
+        return NaN;
+    }
+    const f1Lo = Math.max(f1 / scanFactor, f0Min);
+    const f1Hi = Math.min(f1 * scanFactor, f0Max);
+    const tolerance = Math.min(f1 * relTolerance, absTolerance);
+    return NumApprox.argMax_goldenSectionSearch(salienceFunction, f1Lo, f1Hi, tolerance);
+}
+export function estimatePitch_harmonicSum(samples, sampleRate, position, f0Min = 75, f0Max = 900, parms = getDefaultHarmonicSumParms()) {
+    const salienceFunction = (f0) => harmonicSum(samples, sampleRate, position, f0, parms);
+    return findPitchSalienceFunctionArgMax(salienceFunction, f0Min, f0Max);
+}

package/signal/Resampling.d.ts

@@ -0,0 +1,7 @@
+import { MutableArrayLike } from "../utils/MiscUtils.ts";
+export declare function resampleNearestNeighbor(ia: ArrayLike<number>, oa: MutableArrayLike<number>, preserveScale?: boolean, extraValues?: number): void;
+export declare function resampleNearestNeighborRef(ia: ArrayLike<number>, oa: MutableArrayLike<number>, preserveScale?: boolean, extraValues?: number): void;
+export declare function resampleLinear(ia: ArrayLike<number>, oa: MutableArrayLike<number>, preserveScale?: boolean, extraValues?: number): void;
+export declare function resampleLinearRef(ia: ArrayLike<number>, oa: MutableArrayLike<number>, preserveScale?: boolean, extraValues?: number): void;
+export declare function resampleAverage(ia: ArrayLike<number>, oa: MutableArrayLike<number>): void;
+export declare function resampleAverageRef(ia: ArrayLike<number>, oa: MutableArrayLike<number>): void;

package/signal/Resampling.js

@@ -0,0 +1,218 @@
+import * as ArrayUtils from "../utils/ArrayUtils.js";
+function handleTrivialCases(ia, oa, preserveScale = false, neNe = false) {
+    const iLen = ia.length;
+    const oLen = oa.length;
+    if (iLen == oLen) {
+        ArrayUtils.copy(ia, oa);
+        return true;
+    }
+    if (oLen == 0) {
+        return true;
+    }
+    if (iLen == 0) {
+        ArrayUtils.fill(oa, NaN);
+        return true;
+    }
+    if (iLen == 1) {
+        ArrayUtils.fill(oa, ia[0]);
+        return true;
+    }
+    if (oLen == 1) {
+        if (preserveScale) {
+            oa[0] = ia[0];
+        }
+        else if (neNe) {
+            oa[0] = ia[Math.trunc(iLen / 2)];
+        }
+        else {
+            oa[0] = ArrayUtils.sum(ia) / iLen;
+        }
+        return true;
+    }
+    return false;
+}
+export function resampleNearestNeighbor(ia, oa, preserveScale = false, extraValues = 0) {
+    if (handleTrivialCases(ia, oa, preserveScale, true)) {
+        return;
+    }
+    const iLen = ia.length;
+    const oLen = oa.length;
+    const id = iLen * 2;
+    const od = oLen * 2;
+    const oLen1 = preserveScale ? Math.trunc((iLen - 0.5) / iLen * oLen + 1 - 1E-9) : oLen;
+    let ip = 0;
+    let op = 0;
+    let d = preserveScale ? od / 2 : id / 2;
+    while (op < oLen1) {
+        if (d >= od) {
+            if (od >= id) {
+                ip++;
+                d -= od;
+            }
+            else {
+                const i = Math.trunc(d / od);
+                ip += i;
+                d -= i * od;
+            }
+        }
+        oa[op++] = ia[ip];
+        d += id;
+    }
+    while (op < oLen) {
+        oa[op++] = extraValues;
+    }
+}
+export function resampleNearestNeighborRef(ia, oa, preserveScale = false, extraValues = 0) {
+    if (handleTrivialCases(ia, oa, preserveScale, true)) {
+        return;
+    }
+    for (let op = 0; op < oa.length; op++) {
+        let ip;
+        if (preserveScale) {
+            ip = op / oa.length * ia.length;
+        }
+        else {
+            ip = (op + 0.5) / oa.length * ia.length - 0.5;
+        }
+        if (ip <= ia.length - 0.5 - 1E-9) {
+            oa[op] = interpolateNearestNeighbor(ia, ip);
+        }
+        else {
+            oa[op] = extraValues;
+        }
+    }
+}
+function interpolateNearestNeighbor(a, pos) {
+    if (a.length == 0) {
+        return NaN;
+    }
+    const p0 = Math.round(pos + 1E-9);
+    const p = Math.max(0, Math.min(a.length - 1, p0));
+    return a[p];
+}
+export function resampleLinear(ia, oa, preserveScale = false, extraValues = 0) {
+    if (handleTrivialCases(ia, oa, preserveScale)) {
+        return;
+    }
+    const iLen = ia.length;
+    const oLen = oa.length;
+    const id = preserveScale ? iLen : iLen - 1;
+    const od = preserveScale ? oLen : oLen - 1;
+    const oLen1 = preserveScale ? Math.trunc((iLen - 1) * oLen / iLen + 1 + 1E-9) : oLen;
+    let ip = 0;
+    let op = 0;
+    let d = 0;
+    while (op < oLen1) {
+        if (d >= od) {
+            if (od >= id) {
+                ip++;
+                d -= od;
+            }
+            else {
+                const i = Math.trunc(d / od);
+                ip += i;
+                d -= i * od;
+            }
+        }
+        let x;
+        if (d == 0) {
+            x = ia[ip];
+        }
+        else {
+            x = ia[ip] * ((od - d) / od) + ia[ip + 1] * (d / od);
+        }
+        oa[op++] = x;
+        d += id;
+    }
+    while (op < oLen) {
+        oa[op++] = extraValues;
+    }
+}
+export function resampleLinearRef(ia, oa, preserveScale = false, extraValues = 0) {
+    if (handleTrivialCases(ia, oa, preserveScale)) {
+        return;
+    }
+    for (let op = 0; op < oa.length; op++) {
+        let ip;
+        if (preserveScale) {
+            ip = op / oa.length * ia.length;
+        }
+        else {
+            ip = op / (oa.length - 1) * (ia.length - 1);
+        }
+        if (Math.abs(ip - Math.round(ip)) < 1E-10) {
+            ip = Math.round(ip);
+        }
+        if (ip <= ia.length - 1) {
+            oa[op] = interpolateLinear(ia, ip);
+        }
+        else {
+            oa[op] = extraValues;
+        }
+    }
+}
+function interpolateLinear(a, pos) {
+    const p1 = Math.floor(pos);
+    const p2 = Math.ceil(pos);
+    if (p1 < 0 || p2 >= a.length) {
+        return NaN;
+    }
+    if (p1 == p2) {
+        return a[p1];
+    }
+    const v1 = a[p1];
+    const v2 = a[p2];
+    return v1 + (pos - p1) * (v2 - v1);
+}
+export function resampleAverage(ia, oa) {
+    if (handleTrivialCases(ia, oa)) {
+        return;
+    }
+    const iLen = ia.length;
+    const oLen = oa.length;
+    let ip = 0;
+    let op = 0;
+    let d = 0;
+    while (op < oLen) {
+        d += iLen;
+        let acc = 0;
+        while (d >= oLen) {
+            const w = Math.min(oLen, iLen + oLen - d);
+            acc += ia[ip++] * w;
+            d -= oLen;
+        }
+        if (d > 0) {
+            acc += ia[ip] * Math.min(d, iLen);
+        }
+        oa[op++] = acc / iLen;
+    }
+}
+export function resampleAverageRef(ia, oa) {
+    if (handleTrivialCases(ia, oa)) {
+        return;
+    }
+    const w = 1 / oa.length * ia.length;
+    for (let i = 0; i < oa.length; i++) {
+        const p = i / oa.length * ia.length - 0.5;
+        oa[i] = computeAverageOfRange(ia, p, p + w);
+    }
+}
+function computeAverageOfRange(a, pos1, pos2) {
+    const p1 = Math.max(-0.5, pos1);
+    const p2 = Math.min(a.length - 0.5, pos2);
+    if (p1 >= p2) {
+        return NaN;
+    }
+    const p1i = Math.round(p1);
+    const p2i = Math.min(Math.round(p2), a.length - 1);
+    if (p1i >= p2i) {
+        return a[p1i];
+    }
+    let sum = 0;
+    sum += a[p1i] * (p1i + 0.5 - p1);
+    for (let i = p1i + 1; i < p2i; i++) {
+        sum += a[i];
+    }
+    sum += a[p2i] * (p2 - (p2i - 0.5));
+    return sum / (p2 - p1);
+}

package/signal/WindowFunctions.d.ts

@@ -1,40 +1,40 @@
-export declare type WindowFunction = (x: number) => number;
-export interface WindowFunctionDescr {
-    name: string;
-    id: string;
-    f: WindowFunction;
-    fNorm: WindowFunction;
-    cpuCost: number;
-}
-export declare const windowFunctionIndex: WindowFunctionDescr[];
-export declare function getFunctionDescrById(id: string): WindowFunctionDescr;
-export declare function getFunctionbyId(id: string, { normalize, valueCacheCostLimit, tableCacheCostLimit }?: {
-    normalize?: boolean | undefined;
-    valueCacheCostLimit?: number | undefined;
-    tableCacheCostLimit?: number | undefined;
-}): WindowFunction;
-export declare function getWindowTable(windowFunction: WindowFunction, n: number): Float64Array;
-export declare function applyWindow(a: Float64Array, windowFunction: WindowFunction): Float64Array;
-export declare function applyWindowById(a: Float64Array, windowFunctionId: string): Float64Array;
-export declare function calculateCoherentGain(windowFunction: WindowFunction, n: number): Number;
-export declare function blackmanWindowNorm(x: number): number;
-export declare function blackmanHarrisWindowNorm(x: number): number;
-export declare function blackmanNuttallWindowNorm(x: number): number;
-export declare function flatTopWindowNorm(x: number): number;
-export declare function hammingWindowNorm(x: number): number;
-export declare function hannWindowNorm(x: number): number;
-export declare function nuttallWindowNorm(x: number): number;
-export declare function parabolicWindowNorm(x: number): number;
-export declare function triangularWindowNorm(x: number): number;
-export declare function chdh1WindowNorm(x: number): number;
-export declare function rectangularWindow(x: number): number;
-export declare function triangularWindow(x: number): number;
-export declare function parabolicWindow(x: number): number;
-export declare function hammingWindow(x: number): number;
-export declare function hannWindow(x: number): number;
-export declare function blackmanWindow(x: number): number;
-export declare function blackmanHarrisWindow(x: number): number;
-export declare function blackmanNuttallWindow(x: number): number;
-export declare function nuttallWindow(x: number): number;
-export declare function flatTopWindow(x: number): number;
-export declare function chdh1Window(x: number): number;
+export type WindowFunction = (x: number) => number;
+export interface WindowFunctionDescr {
+    name: string;
+    id: string;
+    f: WindowFunction;
+    fNorm: WindowFunction;
+    cpuCost: number;
+}
+export declare const windowFunctionIndex: WindowFunctionDescr[];
+export declare function getFunctionDescrById(id: string): WindowFunctionDescr;
+export declare function getFunctionbyId(id: string, { normalize, valueCacheCostLimit, tableCacheCostLimit }?: {
+    normalize?: boolean | undefined;
+    valueCacheCostLimit?: number | undefined;
+    tableCacheCostLimit?: number | undefined;
+}): WindowFunction;
+export declare function getWindowTable(windowFunction: WindowFunction, n: number): Float64Array;
+export declare function applyWindow(a: ArrayLike<number>, windowFunction: WindowFunction): Float64Array;
+export declare function applyWindowById(a: ArrayLike<number>, windowFunctionId: string): Float64Array;
+export declare function calculateCoherentGain(windowFunction: WindowFunction, n: number): number;
+export declare function blackmanWindowNorm(x: number): number;
+export declare function blackmanHarrisWindowNorm(x: number): number;
+export declare function blackmanNuttallWindowNorm(x: number): number;
+export declare function flatTopWindowNorm(x: number): number;
+export declare function hammingWindowNorm(x: number): number;
+export declare function hannWindowNorm(x: number): number;
+export declare function nuttallWindowNorm(x: number): number;
+export declare function parabolicWindowNorm(x: number): number;
+export declare function triangularWindowNorm(x: number): number;
+export declare function chdh1WindowNorm(x: number): number;
+export declare function rectangularWindow(x: number): number;
+export declare function triangularWindow(x: number): number;
+export declare function parabolicWindow(x: number): number;
+export declare function hammingWindow(x: number): number;
+export declare function hannWindow(x: number): number;
+export declare function blackmanWindow(x: number): number;
+export declare function blackmanHarrisWindow(x: number): number;
+export declare function blackmanNuttallWindow(x: number): number;
+export declare function nuttallWindow(x: number): number;
+export declare function flatTopWindow(x: number): number;
+export declare function chdh1Window(x: number): number;