dsp-collection 0.2.5 → 0.2.6

package/signal/InstFreq.js

@@ -1,27 +1,26 @@
-import * as AdaptiveStft from "./AdaptiveStft.js";
-export function instFreqSingle_relWindow(samples, position, roughtMeasuringFrequency, shiftFactor, relWindowWidth, windowFunction) {
-    const shiftDistance = Math.max(1, shiftFactor / roughtMeasuringFrequency);
-    const pos1 = position - shiftDistance / 2;
-    const pos2 = position + shiftDistance / 2;
-    const r1 = AdaptiveStft.getSingle_relWindow(samples, roughtMeasuringFrequency, pos1, relWindowWidth, windowFunction);
-    const r2 = AdaptiveStft.getSingle_relWindow(samples, roughtMeasuringFrequency, pos2, relWindowWidth, windowFunction);
-    if (!r1 || !r2) {
-        return;
-    }
-    if (r1.frequency != r2.frequency || r1.windowStartPosition >= r2.windowStartPosition || r1.windowWidth != r2.windowWidth) {
-        throw new Error();
-    }
-    const measuringFrequency = r1.frequency;
-    const realShiftDistance = r2.windowStartPosition - r1.windowStartPosition;
-    const phase1 = r1.component.arg();
-    const phase2 = r2.component.arg();
-    const phaseDelta = (phase2 + 2 * Math.PI - phase1) % (2 * Math.PI);
-    const instFrequency = phaseDelta / (2 * Math.PI) / realShiftDistance;
-    const amplitude = (r1.component.abs() + r2.component.abs()) / 2;
-    return { instFrequency, measuringFrequency, amplitude };
-}
-export function instFreqSingle_maxWindow(samples, position, roughtMeasuringFrequency, shiftFactor, maxWindowWidth, windowFunction) {
-    const relWindowWidth = Math.floor(maxWindowWidth * roughtMeasuringFrequency);
-    return instFreqSingle_relWindow(samples, position, roughtMeasuringFrequency, shiftFactor, relWindowWidth, windowFunction);
-}
-//# sourceMappingURL=InstFreq.js.map
+import * as AdaptiveStft from "./AdaptiveStft.js";
+export function instFreqSingle_relWindow(samples, position, roughtMeasuringFrequency, shiftFactor, relWindowWidth, windowFunction) {
+    const shiftDistance = Math.max(1, shiftFactor / roughtMeasuringFrequency);
+    const pos1 = position - shiftDistance / 2;
+    const pos2 = position + shiftDistance / 2;
+    const r1 = AdaptiveStft.getSingle_relWindow(samples, roughtMeasuringFrequency, pos1, relWindowWidth, windowFunction);
+    const r2 = AdaptiveStft.getSingle_relWindow(samples, roughtMeasuringFrequency, pos2, relWindowWidth, windowFunction);
+    if (!r1 || !r2) {
+        return;
+    }
+    if (r1.frequency != r2.frequency || r1.windowStartPosition >= r2.windowStartPosition || r1.windowWidth != r2.windowWidth) {
+        throw new Error();
+    }
+    const measuringFrequency = r1.frequency;
+    const realShiftDistance = r2.windowStartPosition - r1.windowStartPosition;
+    const phase1 = r1.component.arg();
+    const phase2 = r2.component.arg();
+    const phaseDelta = (phase2 + 2 * Math.PI - phase1) % (2 * Math.PI);
+    const instFrequency = phaseDelta / (2 * Math.PI) / realShiftDistance;
+    const amplitude = (r1.component.abs() + r2.component.abs()) / 2;
+    return { instFrequency, measuringFrequency, amplitude };
+}
+export function instFreqSingle_maxWindow(samples, position, roughtMeasuringFrequency, shiftFactor, maxWindowWidth, windowFunction) {
+    const relWindowWidth = Math.floor(maxWindowWidth * roughtMeasuringFrequency);
+    return instFreqSingle_relWindow(samples, position, roughtMeasuringFrequency, shiftFactor, relWindowWidth, windowFunction);
+}

package/signal/PitchDetectionHarm.d.ts

@@ -1,26 +1,26 @@
-import * as WindowFunctions from "./WindowFunctions.js";
-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;
+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.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);
-}
-//# 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

@@ -1,7 +1,7 @@
-import { MutableArrayLike } from "../utils/MiscUtils.js";
-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;
+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;