echogarden 0.0.1 → 0.1.0

package/dist/dsp/SpeexResampler.js

@@ -0,0 +1,53 @@
+import { cloneRawAudio } from "../audio/AudioUtilities.js";
+import { WasmMemoryManager } from "../utilities/WasmMemoryManager.js";
+let speexResamplerInstance;
+export async function resampleAudioSpeex(rawAudio, outSampleRate, quality = 0) {
+    const channelCount = rawAudio.audioChannels.length;
+    const inSampleRate = rawAudio.sampleRate;
+    if (inSampleRate == outSampleRate) {
+        return cloneRawAudio(rawAudio);
+    }
+    const m = await getSpeexResamplerInstance();
+    const wasmMemory = new WasmMemoryManager(m);
+    function speexResultCodeToString(resultCode) {
+        const errorStrPtr = m._speex_resampler_strerror(resultCode);
+        const errorStrRef = wasmMemory.wrapUint8Array(errorStrPtr, 1024);
+        const message = errorStrRef.readAsNullTerminatedUtf8String();
+        return message;
+    }
+    const initErrRef = wasmMemory.allocInt32();
+    const resamplerState = m._speex_resampler_init(channelCount, inSampleRate, outSampleRate, quality, initErrRef.address);
+    let resultCode = initErrRef.value;
+    if (resultCode != 0) {
+        throw new Error(`Speex resampler failed while initializing with code ${resultCode}: ${speexResultCodeToString(resultCode)}`);
+    }
+    const resampledAudio = { audioChannels: [], sampleRate: outSampleRate };
+    for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+        const channelSamples = rawAudio.audioChannels[channelIndex];
+        const inSampleCount = channelSamples.length;
+        const inSampleCountRef = wasmMemory.allocInt32();
+        inSampleCountRef.value = inSampleCount;
+        const outSampleCount = Math.floor((inSampleCount / inSampleRate) * outSampleRate);
+        const outSampleCountRef = wasmMemory.allocInt32();
+        outSampleCountRef.value = outSampleCount;
+        const inSamplesRef = wasmMemory.allocFloat32Array(inSampleCount);
+        inSamplesRef.view.set(channelSamples);
+        const outSamplesRef = wasmMemory.allocFloat32Array(outSampleCount);
+        resultCode = m._speex_resampler_process_float(resamplerState, channelIndex, inSamplesRef.address, inSampleCountRef.address, outSamplesRef.address, outSampleCountRef.address);
+        if (resultCode != 0) {
+            throw new Error(`Speex resampler failed while resampling with code ${resultCode}: ${speexResultCodeToString(resultCode)}`);
+        }
+        resampledAudio.audioChannels.push(outSamplesRef.view.slice());
+    }
+    m._speex_resampler_destroy(resamplerState);
+    wasmMemory.freeAll();
+    return resampledAudio;
+}
+export async function getSpeexResamplerInstance() {
+    if (!speexResamplerInstance) {
+        const { default: SpeexResamplerInitializer } = await import('@echogarden/speex-resampler-wasm');
+        speexResamplerInstance = await SpeexResamplerInitializer();
+    }
+    return speexResamplerInstance;
+}
+//# sourceMappingURL=SpeexResampler.js.map

package/dist/dsp/SpeexResampler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpeexResampler.js","sourceRoot":"","sources":["../../src/dsp/SpeexResampler.ts"],"names":[],"mappings":"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"}

package/dist/math/VectorMath.d.ts

@@ -0,0 +1,70 @@
+export declare function covarianceMatrixOfSamples(samples: number[][], weights?: number[], biased?: boolean): {
+    covarianceMatrix: number[][];
+    mean: number[];
+};
+export declare function covarianceMatrixOfCenteredSamples(centeredSamples: number[][], biased?: boolean, diagonalRegularizationAmount?: number): number[][];
+export declare function weightedCovarianceMatrixOfCenteredSamples(centeredSamples: number[][], weights: number[], diagonalRegularizationAmount?: number): number[][];
+export declare function centerVectors(vectors: number[][], weights?: number[]): {
+    centeredVectors: number[][];
+    mean: number[];
+};
+export declare function centerVector(vector: number[]): number[];
+export declare function scaleToSumTo1(vector: number[]): number[];
+export declare function normalizeVector(vector: number[], kind?: "population" | "sample"): {
+    normalizedVector: number[];
+    mean: number;
+    stdDeviation: number;
+};
+export declare function normalizeVectors(vectors: number[][], kind?: "population" | "sample"): {
+    normalizedVectors: number[][];
+    mean: number[];
+    stdDeviation: number[];
+};
+export declare function deNormalizeVectors(normalizedVectors: number[][], originalMean: number[], originalStdDeviation: number[]): number[][];
+export declare function meanOfVectors(vectors: number[][]): number[];
+export declare function weightedMeanOfVectors(vectors: number[][], weights: number[]): number[];
+export declare function stdDeviationOfVectors(vectors: number[][], kind?: "population" | "sample", mean?: number[]): number[];
+export declare function varianceOfVectors(vectors: number[][], kind?: "population" | "sample", mean?: number[]): number[];
+export declare function meanOfVector(vector: number[]): number;
+export declare function medianOfVector(vector: number[]): number;
+export declare function stdDeviationOfVector(vector: number[], kind?: "population" | "sample", mean?: number): number;
+export declare function varianceOfVector(vector: number[], kind?: "population" | "sample", mean?: number): number;
+export declare function logOfVector(vector: number[], minVal?: number): number[];
+export declare function expOfVector(vector: number[]): number[];
+export declare function transpose(matrix: number[][]): number[][];
+export declare function movingAverageOfWindow3(vector: number[]): number[];
+export declare function averageMeanSquaredError(actual: number[][], expected: number[][]): number;
+export declare function meanSquaredError(actual: number[], expected: number[]): number;
+export declare function eucledianDistance(vector1: number[], vector2: number[]): number;
+export declare function squaredEucledianDistance(vector1: number[], vector2: number[]): number;
+export declare function cosineDistance(vector1: number[], vector2: number[]): number;
+export declare function cosineSimilarity(vector1: number[], vector2: number[]): number;
+export declare function minkowskiDistance(vector1: number[], vector2: number[], power: number): number;
+export declare function cosineDistancePrecomputedMagnitudes(vector1: number[], vector2: number[], magnitude1: number, magnitude2: number): number;
+export declare function cosineSimilarityPrecomputedMagnitudes(vector1: number[], vector2: number[], magnitude1: number, magnitude2: number): number;
+export declare function subtractVectors(vector1: number[], vector2: number[]): number[];
+export declare function sumVector(vector: number[]): number;
+export declare function dotProduct(vector1: number[], vector2: number[]): number;
+export declare function magnitude(vector: number[]): number;
+export declare function maxValue(vector: number[]): number;
+export declare function indexOfMax(vector: number[]): number;
+export declare function minValue(vector: number[]): number;
+export declare function indexOfMin(vector: number[]): number;
+export declare function exponentialSmoothingMeanOfVectors(vectors: number[][], smoothingFactor: number): number[];
+export declare function sigmoid(x: number): number;
+export declare function softMax(vector: number[], temperature?: number): number[];
+export declare function hammingDistance(value1: number, value2: number, bitLength?: number): number;
+export declare function medianFilter(vector: number[], width: number): any[];
+export declare function createVectorArray(vectorCount: number, featureCount: number, initialValue?: number): number[][];
+export declare function createVector(elementCount: number, initialValue?: number): number[];
+export declare function createVectorForIntegerRange(start: number, end: number): number[];
+export declare function zeroIfNaN(val: number): number;
+export declare function logSumExp(values: number[], minVal?: number): number;
+export declare function sumExp(values: number[]): number;
+export declare function logSoftmax(values: number[], minVal?: number): number[];
+export declare class IncrementalMean {
+    currentElementCount: number;
+    currentMean: number;
+    addValueToMean(value: number): void;
+}
+export type DistanceFunction = (a: number[], b: number[]) => number;

package/dist/math/VectorMath.js

@@ -0,0 +1,564 @@
+import createMedianFilter from 'moving-median';
+export function covarianceMatrixOfSamples(samples, weights, biased = false) {
+    if (samples.length == 0) {
+        throw new Error("No vectors given");
+    }
+    const { centeredVectors: centeredSamples, mean } = centerVectors(samples, weights);
+    let covarianceMatrix;
+    if (weights) {
+        covarianceMatrix = weightedCovarianceMatrixOfCenteredSamples(centeredSamples, weights);
+    }
+    else {
+        covarianceMatrix = covarianceMatrixOfCenteredSamples(centeredSamples, biased);
+    }
+    return { covarianceMatrix, mean };
+}
+export function covarianceMatrixOfCenteredSamples(centeredSamples, biased = false, diagonalRegularizationAmount = 1e-6) {
+    const sampleCount = centeredSamples.length;
+    if (sampleCount == 0) {
+        throw new Error("No vectors given");
+    }
+    const sampleSizeMetric = biased || sampleCount == 1 ? sampleCount : sampleCount - 1;
+    const featureCount = centeredSamples[0].length;
+    const covarianceMatrix = createVectorArray(featureCount, featureCount);
+    if (sampleCount == 1) {
+        return covarianceMatrix;
+    }
+    for (let i = 0; i < featureCount; i++) {
+        for (let j = 0; j < featureCount; j++) {
+            if (i > j) {
+                covarianceMatrix[i][j] = covarianceMatrix[j][i];
+                continue;
+            }
+            let matrixElement = 0.0;
+            for (const sample of centeredSamples) {
+                matrixElement += sample[i] * sample[j];
+            }
+            matrixElement /= sampleSizeMetric;
+            if (i == j) {
+                matrixElement += diagonalRegularizationAmount;
+            }
+            covarianceMatrix[i][j] = matrixElement;
+        }
+    }
+    return covarianceMatrix;
+}
+export function weightedCovarianceMatrixOfCenteredSamples(centeredSamples, weights, diagonalRegularizationAmount = 1e-6) {
+    const sampleCount = centeredSamples.length;
+    if (sampleCount == 0) {
+        throw new Error("No vectors given");
+    }
+    const featureCount = centeredSamples[0].length;
+    const covarianceMatrix = createVectorArray(featureCount, featureCount);
+    if (sampleCount == 1) {
+        return covarianceMatrix;
+    }
+    for (let i = 0; i < featureCount; i++) {
+        for (let j = 0; j < featureCount; j++) {
+            if (i > j) {
+                covarianceMatrix[i][j] = covarianceMatrix[j][i];
+                continue;
+            }
+            let matrixElement = 0.0;
+            for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
+                const sample = centeredSamples[sampleIndex];
+                const weight = weights[sampleIndex];
+                matrixElement += weight * (sample[i] * sample[j]);
+            }
+            if (i == j) {
+                matrixElement += diagonalRegularizationAmount;
+            }
+            covarianceMatrix[i][j] = matrixElement;
+        }
+    }
+    return covarianceMatrix;
+}
+export function centerVectors(vectors, weights) {
+    const vectorCount = vectors.length;
+    if (vectorCount == 0) {
+        return { centeredVectors: [], mean: [] };
+    }
+    let mean;
+    if (weights) {
+        mean = weightedMeanOfVectors(vectors, weights);
+    }
+    else {
+        mean = meanOfVectors(vectors);
+    }
+    const centeredVectors = new Array(vectorCount);
+    for (let i = 0; i < vectorCount; i++) {
+        centeredVectors[i] = subtractVectors(vectors[i], mean);
+    }
+    return { centeredVectors, mean };
+}
+export function centerVector(vector) {
+    const mean = meanOfVector(vector);
+    const centeredVector = new Array(vector.length);
+    for (let i = 0; i < vector.length; i++) {
+        centeredVector[i] = vector[i] - mean;
+    }
+    return centeredVector;
+}
+export function scaleToSumTo1(vector) {
+    if (vector.length == 0) {
+        return [];
+    }
+    if (vector.length == 1) {
+        return [1];
+    }
+    const minValue = vector[indexOfMin(vector)];
+    const scaledVector = vector.slice();
+    if (minValue < 0) {
+        const addedOffset = -minValue * 2;
+        for (let i = 0; i < scaledVector.length; i++) {
+            scaledVector[i] += addedOffset;
+        }
+    }
+    const sum = sumVector(scaledVector);
+    if (sum == 0) {
+        return scaledVector;
+    }
+    if (sum == Infinity) {
+        throw new Error("Vector sum is infinite");
+    }
+    for (let i = 0; i < vector.length; i++) {
+        scaledVector[i] /= sum;
+        scaledVector[i] = zeroIfNaN(scaledVector[i]);
+    }
+    return scaledVector;
+}
+export function normalizeVector(vector, kind = "population") {
+    if (vector.length == 0) {
+        throw new Error("Vector is empty");
+    }
+    const mean = meanOfVector(vector);
+    const stdDeviation = stdDeviationOfVector(vector, kind, mean);
+    const normalizedVector = createVector(vector.length);
+    for (let i = 0; i < vector.length; i++) {
+        normalizedVector[i] = (vector[i] - mean) / stdDeviation;
+        normalizedVector[i] = zeroIfNaN(normalizedVector[i]);
+    }
+    return { normalizedVector, mean, stdDeviation };
+}
+export function normalizeVectors(vectors, kind = "population") {
+    const vectorCount = vectors.length;
+    if (vectorCount == 0) {
+        return { normalizedVectors: [], mean: [], stdDeviation: [] };
+    }
+    const featureCount = vectors[0].length;
+    const mean = meanOfVectors(vectors);
+    const stdDeviation = stdDeviationOfVectors(vectors, kind, mean);
+    const normalizedVectors = [];
+    for (const vector of vectors) {
+        const normalizedVector = createVector(featureCount);
+        for (let featureIndex = 0; featureIndex < featureCount; featureIndex++) {
+            normalizedVector[featureIndex] = (vector[featureIndex] - mean[featureIndex]) / stdDeviation[featureIndex];
+            normalizedVector[featureIndex] = zeroIfNaN(normalizedVector[featureIndex]);
+        }
+        normalizedVectors.push(normalizedVector);
+    }
+    return { normalizedVectors, mean, stdDeviation };
+}
+export function deNormalizeVectors(normalizedVectors, originalMean, originalStdDeviation) {
+    const vectorCount = normalizeVectors.length;
+    if (vectorCount == 0) {
+        return [];
+    }
+    const featureCount = normalizedVectors[0].length;
+    const deNormalizedVectors = [];
+    for (const normalizedVector of normalizedVectors) {
+        const deNormalizedVector = createVector(featureCount);
+        for (let featureIndex = 0; featureIndex < featureCount; featureIndex++) {
+            deNormalizedVector[featureIndex] = originalMean[featureIndex] + (normalizedVector[featureIndex] * originalStdDeviation[featureIndex]);
+        }
+        deNormalizedVectors.push(deNormalizedVector);
+    }
+    return deNormalizedVectors;
+}
+export function meanOfVectors(vectors) {
+    const vectorCount = vectors.length;
+    if (vectorCount == 0) {
+        return [];
+    }
+    const featureCount = vectors[0].length;
+    const result = createVector(featureCount);
+    for (const vector of vectors) {
+        for (let featureIndex = 0; featureIndex < featureCount; featureIndex++) {
+            result[featureIndex] += vector[featureIndex];
+        }
+    }
+    for (let featureIndex = 0; featureIndex < featureCount; featureIndex++) {
+        result[featureIndex] /= vectorCount;
+    }
+    return result;
+}
+export function weightedMeanOfVectors(vectors, weights) {
+    const vectorCount = vectors.length;
+    if (vectorCount == 0) {
+        return [];
+    }
+    const featureCount = vectors[0].length;
+    const result = createVector(featureCount);
+    for (let vectorIndex = 0; vectorIndex < vectorCount; vectorIndex++) {
+        const vector = vectors[vectorIndex];
+        const vectorWeight = weights[vectorIndex];
+        for (let featureIndex = 0; featureIndex < featureCount; featureIndex++) {
+            result[featureIndex] += vectorWeight * vector[featureIndex];
+        }
+    }
+    return result;
+}
+export function stdDeviationOfVectors(vectors, kind = "population", mean) {
+    return varianceOfVectors(vectors, kind, mean).map(v => Math.sqrt(v));
+}
+export function varianceOfVectors(vectors, kind = "population", mean) {
+    const vectorCount = vectors.length;
+    if (vectorCount == 0) {
+        return [];
+    }
+    const sampleSizeMetric = kind == "population" || vectorCount == 1 ? vectorCount : vectorCount - 1;
+    const featureCount = vectors[0].length;
+    if (!mean) {
+        mean = meanOfVectors(vectors);
+    }
+    const result = createVector(featureCount);
+    for (const vector of vectors) {
+        for (let i = 0; i < featureCount; i++) {
+            result[i] += (vector[i] - mean[i]) ** 2;
+        }
+    }
+    for (let i = 0; i < featureCount; i++) {
+        result[i] /= sampleSizeMetric;
+    }
+    return result;
+}
+export function meanOfVector(vector) {
+    if (vector.length == 0) {
+        throw new Error("Vector is empty");
+    }
+    return sumVector(vector) / vector.length;
+}
+export function medianOfVector(vector) {
+    if (vector.length == 0) {
+        throw new Error("Vector is empty");
+    }
+    return vector[Math.floor(vector.length / 2)];
+}
+export function stdDeviationOfVector(vector, kind = "population", mean) {
+    return Math.sqrt(varianceOfVector(vector, kind, mean));
+}
+export function varianceOfVector(vector, kind = "population", mean) {
+    if (vector.length == 0) {
+        throw new Error("Vector is empty");
+    }
+    const sampleSizeMetric = kind == "population" || vector.length == 1 ? vector.length : vector.length - 1;
+    if (mean == null) {
+        mean = meanOfVector(vector);
+    }
+    let result = 0.0;
+    for (const value of vector) {
+        result += (value - mean) ** 2;
+    }
+    return result / sampleSizeMetric;
+}
+export function logOfVector(vector, minVal = 1e-40) {
+    return vector.map(value => Math.log(minVal + value));
+}
+export function expOfVector(vector) {
+    return vector.map(value => Math.exp(value));
+}
+export function transpose(matrix) {
+    const vectorCount = matrix.length;
+    const featureCount = matrix[0].length;
+    const transposedMatrix = createVectorArray(featureCount, vectorCount);
+    for (let i = 0; i < vectorCount; i++) {
+        for (let j = 0; j < featureCount; j++) {
+            transposedMatrix[j][i] = matrix[i][j];
+        }
+    }
+    return transposedMatrix;
+}
+export function movingAverageOfWindow3(vector) {
+    const elementCount = vector.length;
+    if (elementCount == 0) {
+        return [];
+    }
+    if (elementCount == 1) {
+        return vector.slice();
+    }
+    const result = [];
+    result.push((vector[0] + vector[0] + vector[1]) / 3);
+    for (let i = 1; i < elementCount - 1; i++) {
+        result.push((vector[i - 1] + vector[i] + vector[i + 1]) / 3);
+    }
+    result.push((vector[elementCount - 2] + vector[elementCount - 1] + vector[elementCount - 1]) / 3);
+    return result;
+}
+export function averageMeanSquaredError(actual, expected) {
+    if (actual.length != expected.length) {
+        throw new Error("Vectors are not the same length");
+    }
+    const vectorCount = actual.length;
+    if (vectorCount == 0) {
+        return 0;
+    }
+    let sum = 0.0;
+    for (let i = 0; i < vectorCount; i++) {
+        sum += meanSquaredError(actual[i], expected[i]);
+    }
+    return sum / vectorCount;
+}
+export function meanSquaredError(actual, expected) {
+    if (actual.length != expected.length) {
+        throw new Error("Vectors are not the same length");
+    }
+    const featureCount = actual.length;
+    if (featureCount == 0) {
+        return 0;
+    }
+    let sum = 0.0;
+    for (let i = 0; i < featureCount; i++) {
+        sum += (actual[i] - expected[i]) ** 2;
+    }
+    return sum / featureCount;
+}
+export function eucledianDistance(vector1, vector2) {
+    return Math.sqrt(squaredEucledianDistance(vector1, vector2));
+}
+export function squaredEucledianDistance(vector1, vector2) {
+    if (vector1.length != vector2.length) {
+        throw new Error("Vectors are not the same length");
+    }
+    const elementCount = vector1.length;
+    if (elementCount == 0) {
+        return 0;
+    }
+    let sum = 0.0;
+    for (let i = 0; i < elementCount; i++) {
+        sum += (vector1[i] - vector2[i]) ** 2;
+    }
+    return sum;
+}
+export function cosineDistance(vector1, vector2) {
+    return 1 - cosineSimilarity(vector1, vector2);
+}
+export function cosineSimilarity(vector1, vector2) {
+    if (vector1.length != vector2.length) {
+        throw new Error("Vectors are not the same length");
+    }
+    if (vector1.length == 0) {
+        return 0;
+    }
+    const elementCount = vector1.length;
+    let dotProduct = 0.0;
+    let squaredMagnitude1 = 0.0;
+    let squaredMagnitude2 = 0.0;
+    for (let i = 0; i < elementCount; i++) {
+        dotProduct += vector1[i] * vector2[i];
+        squaredMagnitude1 += vector1[i] ** 2;
+        squaredMagnitude2 += vector2[i] ** 2;
+    }
+    const result = dotProduct / (Math.sqrt(squaredMagnitude1) * Math.sqrt(squaredMagnitude2));
+    return zeroIfNaN(result);
+}
+export function minkowskiDistance(vector1, vector2, power) {
+    if (vector1.length != vector2.length) {
+        throw new Error("Vectors are not the same length");
+    }
+    const elementCount = vector1.length;
+    if (elementCount == 0) {
+        return 0;
+    }
+    let sum = 0.0;
+    for (let i = 0; i < elementCount; i++) {
+        sum += Math.abs(vector1[i] - vector2[i]) ** power;
+    }
+    return sum ** (1 / power);
+}
+export function cosineDistancePrecomputedMagnitudes(vector1, vector2, magnitude1, magnitude2) {
+    return 1 - cosineSimilarityPrecomputedMagnitudes(vector1, vector2, magnitude1, magnitude2);
+}
+export function cosineSimilarityPrecomputedMagnitudes(vector1, vector2, magnitude1, magnitude2) {
+    if (vector1.length != vector2.length) {
+        throw new Error("Vectors are not the same length");
+    }
+    if (vector1.length == 0) {
+        return 0;
+    }
+    const featureCount = vector1.length;
+    let dotProduct = 0.0;
+    for (let i = 0; i < featureCount; i++) {
+        dotProduct += vector1[i] * vector2[i];
+    }
+    const result = dotProduct / (magnitude1 * magnitude2);
+    return zeroIfNaN(result);
+}
+export function subtractVectors(vector1, vector2) {
+    if (vector1.length != vector2.length) {
+        throw new Error("Vectors are not the same length");
+    }
+    const result = createVector(vector1.length);
+    for (let i = 0; i < vector1.length; i++) {
+        result[i] = vector1[i] - vector2[i];
+    }
+    return result;
+}
+export function sumVector(vector) {
+    let result = 0.0;
+    for (let i = 0; i < vector.length; i++) {
+        result += vector[i];
+    }
+    return result;
+}
+export function dotProduct(vector1, vector2) {
+    if (vector1.length != vector2.length) {
+        throw new Error("Vectors are not the same length");
+    }
+    const elementCount = vector1.length;
+    let result = 0.0;
+    for (let i = 0; i < elementCount; i++) {
+        result += vector1[i] * vector2[i];
+    }
+    return result;
+}
+export function magnitude(vector) {
+    const featureCount = vector.length;
+    let squaredMagnitude = 0.0;
+    for (let i = 0; i < featureCount; i++) {
+        squaredMagnitude += vector[i] ** 2;
+    }
+    return Math.sqrt(squaredMagnitude);
+}
+export function maxValue(vector) {
+    return vector[indexOfMax(vector)];
+}
+export function indexOfMax(vector) {
+    let maxValue = -Infinity;
+    let result = -1;
+    for (let i = 0; i < vector.length; i++) {
+        if (vector[i] > maxValue) {
+            maxValue = vector[i];
+            result = i;
+        }
+    }
+    return result;
+}
+export function minValue(vector) {
+    return vector[indexOfMin(vector)];
+}
+export function indexOfMin(vector) {
+    let minValue = Infinity;
+    let result = -1;
+    for (let i = 0; i < vector.length; i++) {
+        if (vector[i] < minValue) {
+            minValue = vector[i];
+            result = i;
+        }
+    }
+    return result;
+}
+export function exponentialSmoothingMeanOfVectors(vectors, smoothingFactor) {
+    const vectorCount = vectors.length;
+    if (vectorCount == 0) {
+        return [];
+    }
+    const featureCount = vectors[0].length;
+    const currentEstimate = createVector(featureCount);
+    for (let i = 0; i < vectorCount; i++) {
+        for (let j = 0; j < featureCount; j++) {
+            const value = vectors[i][j];
+            currentEstimate[j] = (smoothingFactor * value) + ((1 - smoothingFactor) * currentEstimate[j]);
+        }
+    }
+    return currentEstimate;
+}
+export function sigmoid(x) {
+    const result = 1 / (1 + Math.exp(-x));
+    return zeroIfNaN(result);
+}
+export function softMax(vector, temperature = 1.0) {
+    if (vector.length == 0) {
+        return [];
+    }
+    const result = [];
+    let sumOfExponentiatedValues = 0.0;
+    for (const value of vector) {
+        const eToValue = Math.exp(value / temperature);
+        sumOfExponentiatedValues += eToValue;
+        result.push(eToValue);
+    }
+    for (let i = 0; i < result.length; i++) {
+        result[i] /= sumOfExponentiatedValues;
+        result[i] = zeroIfNaN(result[i]);
+    }
+    return result;
+}
+export function hammingDistance(value1, value2, bitLength = 32) {
+    let valueXor = value1 ^ value2;
+    let result = 0;
+    for (let i = 0; i < bitLength; i++) {
+        result += valueXor & 1;
+        valueXor = valueXor >> 1;
+    }
+    return result;
+}
+export function medianFilter(vector, width) {
+    const filter = createMedianFilter(width);
+    const result = [];
+    for (let i = 0; i < vector.length; i++) {
+        result.push(filter(vector[i]));
+    }
+    return result;
+}
+export function createVectorArray(vectorCount, featureCount, initialValue = 0.0) {
+    const result = new Array(vectorCount);
+    for (let i = 0; i < vectorCount; i++) {
+        result[i] = createVector(featureCount, initialValue);
+    }
+    return result;
+}
+export function createVector(elementCount, initialValue = 0.0) {
+    const result = new Array(elementCount);
+    for (let i = 0; i < elementCount; i++) {
+        result[i] = initialValue;
+    }
+    return result;
+}
+export function createVectorForIntegerRange(start, end) {
+    const newVector = [];
+    for (let i = start; i < end; i++) {
+        newVector.push(i);
+    }
+    return newVector;
+}
+export function zeroIfNaN(val) {
+    if (isNaN(val)) {
+        return 0;
+    }
+    else {
+        return val;
+    }
+}
+export function logSumExp(values, minVal = 1e-40) {
+    return Math.log(minVal + sumExp(values));
+}
+export function sumExp(values) {
+    let sumOfExp = 0;
+    for (const value of values) {
+        sumOfExp += Math.exp(value);
+    }
+    return sumOfExp;
+}
+export function logSoftmax(values, minVal = 1e-40) {
+    const softMaxOfValues = softMax(values);
+    return logOfVector(softMaxOfValues, minVal);
+}
+export class IncrementalMean {
+    currentElementCount = 0;
+    currentMean = 0.0;
+    addValueToMean(value) {
+        this.currentElementCount += 1;
+        this.currentMean += (value + this.currentMean) / this.currentElementCount;
+    }
+}
+//# sourceMappingURL=VectorMath.js.map