@elarsaks/umap-wasm 0.1.2 → 0.1.4

package/dist/umap.js

@@ -0,0 +1,700 @@
+import * as heap from './heap.js';
+import * as matrix from './matrix.js';
+import * as nnDescent from './nn_descent.js';
+import * as tree from './tree.js';
+import * as utils from './utils.js';
+import LM from 'ml-levenberg-marquardt';
+import * as wasmBridge from './wasmBridge.js';
+const SMOOTH_K_TOLERANCE = 1e-5;
+const MIN_K_DIST_SCALE = 1e-3;
+export class UMAP {
+    constructor(params = {}) {
+        this.learningRate = 1.0;
+        this.localConnectivity = 1.0;
+        this.minDist = 0.1;
+        this.nComponents = 2;
+        this.nEpochs = 0;
+        this.nNeighbors = 15;
+        this.negativeSampleRate = 5;
+        this.random = Math.random;
+        this.repulsionStrength = 1.0;
+        this.setOpMixRatio = 1.0;
+        this.spread = 1.0;
+        this.transformQueueSize = 4.0;
+        this.targetMetric = "categorical";
+        this.targetWeight = 0.5;
+        this.targetNNeighbors = this.nNeighbors;
+        this.distanceFn = euclidean;
+        this.useWasmDistance = false;
+        this.useWasmMatrix = false;
+        this.useWasmTree = false;
+        this.isInitialized = false;
+        this.rpForest = [];
+        this.embedding = [];
+        this.optimizationState = new OptimizationState();
+        const setParam = (key) => {
+            if (params[key] !== undefined)
+                this[key] = params[key];
+        };
+        setParam('distanceFn');
+        setParam('useWasmDistance');
+        setParam('useWasmMatrix');
+        setParam('useWasmTree');
+        setParam('learningRate');
+        setParam('localConnectivity');
+        setParam('minDist');
+        setParam('nComponents');
+        setParam('nEpochs');
+        setParam('nNeighbors');
+        setParam('negativeSampleRate');
+        setParam('random');
+        setParam('repulsionStrength');
+        setParam('setOpMixRatio');
+        setParam('spread');
+        setParam('transformQueueSize');
+    }
+    fit(X) {
+        this.initializeFit(X);
+        this.optimizeLayout();
+        return this.embedding;
+    }
+    async fitAsync(X, callback = () => true) {
+        this.initializeFit(X);
+        await this.optimizeLayoutAsync(callback);
+        return this.embedding;
+    }
+    setSupervisedProjection(Y, params = {}) {
+        this.Y = Y;
+        this.targetMetric = params.targetMetric || this.targetMetric;
+        this.targetWeight = params.targetWeight || this.targetWeight;
+        this.targetNNeighbors = params.targetNNeighbors || this.targetNNeighbors;
+    }
+    setPrecomputedKNN(knnIndices, knnDistances) {
+        this.knnIndices = knnIndices;
+        this.knnDistances = knnDistances;
+    }
+    initializeFit(X) {
+        if (X.length <= this.nNeighbors) {
+            throw new Error(`Not enough data points (${X.length}) to create nNeighbors: ${this.nNeighbors}.  Add more data points or adjust the configuration.`);
+        }
+        if (this.X === X && this.isInitialized) {
+            return this.getNEpochs();
+        }
+        this.X = X;
+        if (!this.knnIndices && !this.knnDistances) {
+            const knnResults = this.nearestNeighbors(X);
+            this.knnIndices = knnResults.knnIndices;
+            this.knnDistances = knnResults.knnDistances;
+        }
+        this.graph = this.fuzzySimplicialSet(X, this.nNeighbors, this.setOpMixRatio);
+        this.makeSearchFns();
+        this.searchGraph = this.makeSearchGraph(X);
+        this.processGraphForSupervisedProjection();
+        const { head, tail, epochsPerSample, } = this.initializeSimplicialSetEmbedding();
+        this.optimizationState.head = head;
+        this.optimizationState.tail = tail;
+        this.optimizationState.epochsPerSample = epochsPerSample;
+        this.initializeOptimization();
+        this.prepareForOptimizationLoop();
+        this.isInitialized = true;
+        return this.getNEpochs();
+    }
+    makeSearchFns() {
+        const distanceWrapper = (a, b) => {
+            if (this.useWasmDistance) {
+                if (!wasmBridge.isWasmAvailable()) {
+                    throw new Error('WASM distance requested via `useWasmDistance: true` but the wasm module is not initialized or available. ' +
+                        'Call `await wasmBridge.initWasm()` before using UMAP with wasm distances or build the wasm package.');
+                }
+                return wasmBridge.euclideanWasm(a, b);
+            }
+            return this.distanceFn(a, b);
+        };
+        const { initFromTree, initFromRandom } = nnDescent.makeInitializations(distanceWrapper);
+        this.initFromTree = initFromTree;
+        this.initFromRandom = initFromRandom;
+        this.search = nnDescent.makeInitializedNNSearch(distanceWrapper);
+    }
+    computeDistance(a, b) {
+        if (this.useWasmDistance) {
+            if (!wasmBridge.isWasmAvailable()) {
+                throw new Error('WASM distance requested via `useWasmDistance: true` but the wasm module is not initialized or available. ' +
+                    'Call `await wasmBridge.initWasm()` before using UMAP with wasm distances or build the wasm package.');
+            }
+            return wasmBridge.euclideanWasm(a, b);
+        }
+        return this.distanceFn(a, b);
+    }
+    makeSearchGraph(X) {
+        const knnIndices = this.knnIndices;
+        const knnDistances = this.knnDistances;
+        const dims = [X.length, X.length];
+        const searchGraph = new matrix.SparseMatrix([], [], [], dims);
+        for (let i = 0; i < knnIndices.length; i++) {
+            const knn = knnIndices[i];
+            const distances = knnDistances[i];
+            for (let j = 0; j < knn.length; j++) {
+                const neighbor = knn[j];
+                const distance = distances[j];
+                if (distance > 0) {
+                    searchGraph.set(i, neighbor, distance);
+                }
+            }
+        }
+        const transpose = matrix.transpose(searchGraph);
+        return matrix.maximum(searchGraph, transpose);
+    }
+    transform(toTransform) {
+        const rawData = this.X;
+        if (rawData === undefined || rawData.length === 0) {
+            throw new Error('No data has been fit.');
+        }
+        let nNeighbors = Math.floor(this.nNeighbors * this.transformQueueSize);
+        nNeighbors = Math.min(rawData.length, nNeighbors);
+        const init = nnDescent.initializeSearch(this.rpForest, rawData, toTransform, nNeighbors, this.initFromRandom, this.initFromTree, this.random);
+        const result = this.search(rawData, this.searchGraph, init, toTransform);
+        let { indices, weights: distances } = heap.deheapSort(result);
+        indices = indices.map(x => x.slice(0, this.nNeighbors));
+        distances = distances.map(x => x.slice(0, this.nNeighbors));
+        const adjustedLocalConnectivity = Math.max(0, this.localConnectivity - 1);
+        const { sigmas, rhos } = this.smoothKNNDistance(distances, this.nNeighbors, adjustedLocalConnectivity);
+        const { rows, cols, vals } = this.computeMembershipStrengths(indices, distances, sigmas, rhos);
+        const size = [toTransform.length, rawData.length];
+        let graph = new matrix.SparseMatrix(rows, cols, vals, size);
+        const normed = matrix.normalize(graph, "l1");
+        const csrMatrix = matrix.getCSR(normed);
+        const nPoints = toTransform.length;
+        const eIndices = utils.reshape2d(csrMatrix.indices, nPoints, this.nNeighbors);
+        const eWeights = utils.reshape2d(csrMatrix.values, nPoints, this.nNeighbors);
+        const embedding = initTransform(eIndices, eWeights, this.embedding);
+        const nEpochs = this.nEpochs
+            ? this.nEpochs / 3
+            : graph.nRows <= 10000
+                ? 100
+                : 30;
+        const graphMax = graph
+            .getValues()
+            .reduce((max, val) => (val > max ? val : max), 0);
+        graph = graph.map(value => (value < graphMax / nEpochs ? 0 : value));
+        graph = matrix.eliminateZeros(graph);
+        const epochsPerSample = this.makeEpochsPerSample(graph.getValues(), nEpochs);
+        const head = graph.getRows();
+        const tail = graph.getCols();
+        this.assignOptimizationStateParameters({
+            headEmbedding: embedding,
+            tailEmbedding: this.embedding,
+            head,
+            tail,
+            currentEpoch: 0,
+            nEpochs,
+            nVertices: graph.getDims()[1],
+            epochsPerSample,
+        });
+        this.prepareForOptimizationLoop();
+        return this.optimizeLayout();
+    }
+    processGraphForSupervisedProjection() {
+        const { Y, X } = this;
+        if (Y) {
+            if (Y.length !== X.length) {
+                throw new Error('Length of X and y must be equal');
+            }
+            if (this.targetMetric === "categorical") {
+                const lt = this.targetWeight < 1.0;
+                const farDist = lt ? 2.5 * (1.0 / (1.0 - this.targetWeight)) : 1.0e12;
+                this.graph = this.categoricalSimplicialSetIntersection(this.graph, Y, farDist);
+            }
+        }
+    }
+    step() {
+        const { currentEpoch } = this.optimizationState;
+        if (currentEpoch < this.getNEpochs()) {
+            this.optimizeLayoutStep(currentEpoch);
+        }
+        return this.optimizationState.currentEpoch;
+    }
+    getEmbedding() {
+        return this.embedding;
+    }
+    nearestNeighbors(X) {
+        const { distanceFn, nNeighbors } = this;
+        const log2 = (n) => Math.log(n) / Math.log(2);
+        const metricNNDescent = nnDescent.makeNNDescent(distanceFn, this.random);
+        const round = (n) => {
+            return n === 0.5 ? 0 : Math.round(n);
+        };
+        const nTrees = 5 + Math.floor(round(X.length ** 0.5 / 20.0));
+        const nIters = Math.max(5, Math.floor(Math.round(log2(X.length))));
+        this.rpForest = tree.makeForest(X, nNeighbors, nTrees, this.random, this.useWasmTree);
+        const leafArray = tree.makeLeafArray(this.rpForest);
+        const { indices, weights } = metricNNDescent(X, leafArray, nNeighbors, nIters);
+        return { knnIndices: indices, knnDistances: weights };
+    }
+    fuzzySimplicialSet(X, nNeighbors, setOpMixRatio = 1.0) {
+        const { knnIndices = [], knnDistances = [], localConnectivity } = this;
+        const { sigmas, rhos } = this.smoothKNNDistance(knnDistances, nNeighbors, localConnectivity);
+        const { rows, cols, vals } = this.computeMembershipStrengths(knnIndices, knnDistances, sigmas, rhos);
+        const size = [X.length, X.length];
+        if (this.useWasmMatrix && wasmBridge.isWasmAvailable()) {
+            const wasmMat = wasmBridge.createSparseMatrixWasm(rows, cols, vals, size[0], size[1]);
+            const transpose = wasmBridge.sparseTransposeWasm(wasmMat);
+            const prodMatrix = wasmBridge.sparsePairwiseMultiplyWasm(wasmMat, transpose);
+            const added = wasmBridge.sparseAddWasm(wasmMat, transpose);
+            const a = wasmBridge.sparseSubtractWasm(added, prodMatrix);
+            const b = wasmBridge.sparseMultiplyScalarWasm(a, setOpMixRatio);
+            const c = wasmBridge.sparseMultiplyScalarWasm(prodMatrix, 1.0 - setOpMixRatio);
+            const resultWasm = wasmBridge.sparseAddWasm(b, c);
+            const entries = wasmBridge.wasmSparseMatrixGetAll(resultWasm);
+            const jsRows = entries.map(e => e.row);
+            const jsCols = entries.map(e => e.col);
+            const jsVals = entries.map(e => e.value);
+            return new matrix.SparseMatrix(jsRows, jsCols, jsVals, size);
+        }
+        if (this.useWasmMatrix && wasmBridge.isWasmAvailable()) {
+            const wasmMat = wasmBridge.createSparseMatrixWasm(rows, cols, vals, size[0], size[1]);
+            const transpose = wasmBridge.sparseTransposeWasm(wasmMat);
+            const prodMatrix = wasmBridge.sparsePairwiseMultiplyWasm(wasmMat, transpose);
+            const added = wasmBridge.sparseAddWasm(wasmMat, transpose);
+            const a = wasmBridge.sparseSubtractWasm(added, prodMatrix);
+            const b = wasmBridge.sparseMultiplyScalarWasm(a, setOpMixRatio);
+            const c = wasmBridge.sparseMultiplyScalarWasm(prodMatrix, 1.0 - setOpMixRatio);
+            const resultWasm = wasmBridge.sparseAddWasm(b, c);
+            const entries = wasmBridge.wasmSparseMatrixGetAll(resultWasm);
+            const jsRows = entries.map(e => e.row);
+            const jsCols = entries.map(e => e.col);
+            const jsVals = entries.map(e => e.value);
+            return new matrix.SparseMatrix(jsRows, jsCols, jsVals, size);
+        }
+        const sparseMatrix = new matrix.SparseMatrix(rows, cols, vals, size);
+        const transpose = matrix.transpose(sparseMatrix);
+        const prodMatrix = matrix.pairwiseMultiply(sparseMatrix, transpose);
+        const a = matrix.subtract(matrix.add(sparseMatrix, transpose), prodMatrix);
+        const b = matrix.multiplyScalar(a, setOpMixRatio);
+        const c = matrix.multiplyScalar(prodMatrix, 1.0 - setOpMixRatio);
+        const result = matrix.add(b, c);
+        return result;
+    }
+    categoricalSimplicialSetIntersection(simplicialSet, target, farDist, unknownDist = 1.0) {
+        let intersection = fastIntersection(simplicialSet, target, unknownDist, farDist);
+        intersection = matrix.eliminateZeros(intersection);
+        return resetLocalConnectivity(intersection);
+    }
+    smoothKNNDistance(distances, k, localConnectivity = 1.0, nIter = 64, bandwidth = 1.0) {
+        const target = (Math.log(k) / Math.log(2)) * bandwidth;
+        const rho = utils.zeros(distances.length);
+        const result = utils.zeros(distances.length);
+        for (let i = 0; i < distances.length; i++) {
+            let lo = 0.0;
+            let hi = Infinity;
+            let mid = 1.0;
+            const ithDistances = distances[i];
+            const nonZeroDists = ithDistances.filter(d => d > 0.0);
+            if (nonZeroDists.length >= localConnectivity) {
+                let index = Math.floor(localConnectivity);
+                let interpolation = localConnectivity - index;
+                if (index > 0) {
+                    rho[i] = nonZeroDists[index - 1];
+                    if (interpolation > SMOOTH_K_TOLERANCE) {
+                        rho[i] +=
+                            interpolation * (nonZeroDists[index] - nonZeroDists[index - 1]);
+                    }
+                }
+                else {
+                    rho[i] = interpolation * nonZeroDists[0];
+                }
+            }
+            else if (nonZeroDists.length > 0) {
+                rho[i] = utils.max(nonZeroDists);
+            }
+            for (let n = 0; n < nIter; n++) {
+                let psum = 0.0;
+                for (let j = 1; j < distances[i].length; j++) {
+                    const d = distances[i][j] - rho[i];
+                    if (d > 0) {
+                        psum += Math.exp(-(d / mid));
+                    }
+                    else {
+                        psum += 1.0;
+                    }
+                }
+                if (Math.abs(psum - target) < SMOOTH_K_TOLERANCE) {
+                    break;
+                }
+                if (psum > target) {
+                    hi = mid;
+                    mid = (lo + hi) / 2.0;
+                }
+                else {
+                    lo = mid;
+                    if (hi === Infinity) {
+                        mid *= 2;
+                    }
+                    else {
+                        mid = (lo + hi) / 2.0;
+                    }
+                }
+            }
+            result[i] = mid;
+            if (rho[i] > 0.0) {
+                const meanIthDistances = utils.mean(ithDistances);
+                if (result[i] < MIN_K_DIST_SCALE * meanIthDistances) {
+                    result[i] = MIN_K_DIST_SCALE * meanIthDistances;
+                }
+            }
+            else {
+                const meanDistances = utils.mean(distances.map(utils.mean));
+                if (result[i] < MIN_K_DIST_SCALE * meanDistances) {
+                    result[i] = MIN_K_DIST_SCALE * meanDistances;
+                }
+            }
+        }
+        return { sigmas: result, rhos: rho };
+    }
+    computeMembershipStrengths(knnIndices, knnDistances, sigmas, rhos) {
+        const nSamples = knnIndices.length;
+        const nNeighbors = knnIndices[0].length;
+        const rows = utils.zeros(nSamples * nNeighbors);
+        const cols = utils.zeros(nSamples * nNeighbors);
+        const vals = utils.zeros(nSamples * nNeighbors);
+        for (let i = 0; i < nSamples; i++) {
+            for (let j = 0; j < nNeighbors; j++) {
+                let val = 0;
+                if (knnIndices[i][j] === -1) {
+                    continue;
+                }
+                if (knnIndices[i][j] === i) {
+                    val = 0.0;
+                }
+                else if (knnDistances[i][j] - rhos[i] <= 0.0) {
+                    val = 1.0;
+                }
+                else {
+                    val = Math.exp(-((knnDistances[i][j] - rhos[i]) / sigmas[i]));
+                }
+                rows[i * nNeighbors + j] = i;
+                cols[i * nNeighbors + j] = knnIndices[i][j];
+                vals[i * nNeighbors + j] = val;
+            }
+        }
+        return { rows, cols, vals };
+    }
+    initializeSimplicialSetEmbedding() {
+        const nEpochs = this.getNEpochs();
+        const { nComponents } = this;
+        const graphValues = this.graph.getValues();
+        let graphMax = 0;
+        for (let i = 0; i < graphValues.length; i++) {
+            const value = graphValues[i];
+            if (graphMax < graphValues[i]) {
+                graphMax = value;
+            }
+        }
+        const graph = this.graph.map(value => {
+            if (value < graphMax / nEpochs) {
+                return 0;
+            }
+            else {
+                return value;
+            }
+        });
+        this.embedding = utils.zeros(graph.nRows).map(() => {
+            return utils.zeros(nComponents).map(() => {
+                return utils.tauRand(this.random) * 20 + -10;
+            });
+        });
+        const weights = [];
+        const head = [];
+        const tail = [];
+        const rowColValues = graph.getAll();
+        for (let i = 0; i < rowColValues.length; i++) {
+            const entry = rowColValues[i];
+            if (entry.value) {
+                weights.push(entry.value);
+                tail.push(entry.row);
+                head.push(entry.col);
+            }
+        }
+        const epochsPerSample = this.makeEpochsPerSample(weights, nEpochs);
+        return { head, tail, epochsPerSample };
+    }
+    makeEpochsPerSample(weights, nEpochs) {
+        const result = utils.filled(weights.length, -1.0);
+        const max = utils.max(weights);
+        const nSamples = weights.map(w => (w / max) * nEpochs);
+        nSamples.forEach((n, i) => {
+            if (n > 0)
+                result[i] = nEpochs / nSamples[i];
+        });
+        return result;
+    }
+    assignOptimizationStateParameters(state) {
+        Object.assign(this.optimizationState, state);
+    }
+    prepareForOptimizationLoop() {
+        const { repulsionStrength, learningRate, negativeSampleRate } = this;
+        const { epochsPerSample, headEmbedding, tailEmbedding, } = this.optimizationState;
+        const dim = headEmbedding[0].length;
+        const moveOther = headEmbedding.length === tailEmbedding.length;
+        const epochsPerNegativeSample = epochsPerSample.map(e => e / negativeSampleRate);
+        const epochOfNextNegativeSample = [...epochsPerNegativeSample];
+        const epochOfNextSample = [...epochsPerSample];
+        this.assignOptimizationStateParameters({
+            epochOfNextSample,
+            epochOfNextNegativeSample,
+            epochsPerNegativeSample,
+            moveOther,
+            initialAlpha: learningRate,
+            alpha: learningRate,
+            gamma: repulsionStrength,
+            dim,
+        });
+    }
+    initializeOptimization() {
+        const headEmbedding = this.embedding;
+        const tailEmbedding = this.embedding;
+        const { head, tail, epochsPerSample } = this.optimizationState;
+        const nEpochs = this.getNEpochs();
+        const nVertices = this.graph.nCols;
+        const { a, b } = findABParams(this.spread, this.minDist);
+        this.assignOptimizationStateParameters({
+            headEmbedding,
+            tailEmbedding,
+            head,
+            tail,
+            epochsPerSample,
+            a,
+            b,
+            nEpochs,
+            nVertices,
+        });
+    }
+    optimizeLayoutStep(n) {
+        const { optimizationState } = this;
+        const { head, tail, headEmbedding, tailEmbedding, epochsPerSample, epochOfNextSample, epochOfNextNegativeSample, epochsPerNegativeSample, moveOther, initialAlpha, alpha, gamma, a, b, dim, nEpochs, nVertices, } = optimizationState;
+        const clipValue = 4.0;
+        for (let i = 0; i < epochsPerSample.length; i++) {
+            if (epochOfNextSample[i] > n) {
+                continue;
+            }
+            const j = head[i];
+            const k = tail[i];
+            const current = headEmbedding[j];
+            const other = tailEmbedding[k];
+            const distSquared = rDist(current, other);
+            let gradCoeff = 0;
+            if (distSquared > 0) {
+                gradCoeff = -2.0 * a * b * Math.pow(distSquared, b - 1.0);
+                gradCoeff /= a * Math.pow(distSquared, b) + 1.0;
+            }
+            for (let d = 0; d < dim; d++) {
+                const gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);
+                current[d] += gradD * alpha;
+                if (moveOther) {
+                    other[d] += -gradD * alpha;
+                }
+            }
+            epochOfNextSample[i] += epochsPerSample[i];
+            const nNegSamples = Math.floor((n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]);
+            for (let p = 0; p < nNegSamples; p++) {
+                const k = utils.tauRandInt(nVertices, this.random);
+                const other = tailEmbedding[k];
+                const distSquared = rDist(current, other);
+                let gradCoeff = 0.0;
+                if (distSquared > 0.0) {
+                    gradCoeff = 2.0 * gamma * b;
+                    gradCoeff /=
+                        (0.001 + distSquared) * (a * Math.pow(distSquared, b) + 1);
+                }
+                else if (j === k) {
+                    continue;
+                }
+                for (let d = 0; d < dim; d++) {
+                    let gradD = 4.0;
+                    if (gradCoeff > 0.0) {
+                        gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);
+                    }
+                    current[d] += gradD * alpha;
+                }
+            }
+            epochOfNextNegativeSample[i] += nNegSamples * epochsPerNegativeSample[i];
+        }
+        optimizationState.alpha = initialAlpha * (1.0 - n / nEpochs);
+        optimizationState.currentEpoch += 1;
+        return headEmbedding;
+    }
+    optimizeLayoutAsync(epochCallback = () => true) {
+        return new Promise((resolve, reject) => {
+            const step = async () => {
+                try {
+                    const { nEpochs, currentEpoch } = this.optimizationState;
+                    this.embedding = this.optimizeLayoutStep(currentEpoch);
+                    const epochCompleted = this.optimizationState.currentEpoch;
+                    const shouldStop = epochCallback(epochCompleted) === false;
+                    const isFinished = epochCompleted === nEpochs;
+                    if (!shouldStop && !isFinished) {
+                        setTimeout(() => step(), 0);
+                    }
+                    else {
+                        return resolve(isFinished);
+                    }
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+            setTimeout(() => step(), 0);
+        });
+    }
+    optimizeLayout(epochCallback = () => true) {
+        let isFinished = false;
+        let embedding = [];
+        while (!isFinished) {
+            const { nEpochs, currentEpoch } = this.optimizationState;
+            embedding = this.optimizeLayoutStep(currentEpoch);
+            const epochCompleted = this.optimizationState.currentEpoch;
+            const shouldStop = epochCallback(epochCompleted) === false;
+            isFinished = epochCompleted === nEpochs || shouldStop;
+        }
+        return embedding;
+    }
+    getNEpochs() {
+        const graph = this.graph;
+        if (this.nEpochs > 0) {
+            return this.nEpochs;
+        }
+        const length = graph.nRows;
+        if (length <= 2500) {
+            return 500;
+        }
+        else if (length <= 5000) {
+            return 400;
+        }
+        else if (length <= 7500) {
+            return 300;
+        }
+        else {
+            return 200;
+        }
+    }
+}
+export function euclidean(x, y) {
+    let result = 0;
+    for (let i = 0; i < x.length; i++) {
+        result += (x[i] - y[i]) ** 2;
+    }
+    return Math.sqrt(result);
+}
+export function cosine(x, y) {
+    let result = 0.0;
+    let normX = 0.0;
+    let normY = 0.0;
+    for (let i = 0; i < x.length; i++) {
+        result += x[i] * y[i];
+        normX += x[i] ** 2;
+        normY += y[i] ** 2;
+    }
+    if (normX === 0 && normY === 0) {
+        return 0;
+    }
+    else if (normX === 0 || normY === 0) {
+        return 1.0;
+    }
+    else {
+        return 1.0 - result / Math.sqrt(normX * normY);
+    }
+}
+class OptimizationState {
+    constructor() {
+        this.currentEpoch = 0;
+        this.headEmbedding = [];
+        this.tailEmbedding = [];
+        this.head = [];
+        this.tail = [];
+        this.epochsPerSample = [];
+        this.epochOfNextSample = [];
+        this.epochOfNextNegativeSample = [];
+        this.epochsPerNegativeSample = [];
+        this.moveOther = true;
+        this.initialAlpha = 1.0;
+        this.alpha = 1.0;
+        this.gamma = 1.0;
+        this.a = 1.5769434603113077;
+        this.b = 0.8950608779109733;
+        this.dim = 2;
+        this.nEpochs = 500;
+        this.nVertices = 0;
+    }
+}
+function clip(x, clipValue) {
+    if (x > clipValue)
+        return clipValue;
+    else if (x < -clipValue)
+        return -clipValue;
+    else
+        return x;
+}
+function rDist(x, y) {
+    let result = 0.0;
+    for (let i = 0; i < x.length; i++) {
+        result += Math.pow(x[i] - y[i], 2);
+    }
+    return result;
+}
+export function findABParams(spread, minDist) {
+    const curve = ([a, b]) => (x) => {
+        return 1.0 / (1.0 + a * x ** (2 * b));
+    };
+    const xv = utils
+        .linear(0, spread * 3, 300)
+        .map(val => (val < minDist ? 1.0 : val));
+    const yv = utils.zeros(xv.length).map((val, index) => {
+        const gte = xv[index] >= minDist;
+        return gte ? Math.exp(-(xv[index] - minDist) / spread) : val;
+    });
+    const initialValues = [0.5, 0.5];
+    const data = { x: xv, y: yv };
+    const options = {
+        damping: 1.5,
+        initialValues,
+        gradientDifference: 10e-2,
+        maxIterations: 100,
+        errorTolerance: 10e-3,
+    };
+    const { parameterValues } = LM(data, curve, options);
+    const [a, b] = parameterValues;
+    return { a, b };
+}
+export function fastIntersection(graph, target, unknownDist = 1.0, farDist = 5.0) {
+    return graph.map((value, row, col) => {
+        if (target[row] === -1 || target[col] === -1) {
+            return value * Math.exp(-unknownDist);
+        }
+        else if (target[row] !== target[col]) {
+            return value * Math.exp(-farDist);
+        }
+        else {
+            return value;
+        }
+    });
+}
+export function resetLocalConnectivity(simplicialSet) {
+    simplicialSet = matrix.normalize(simplicialSet, "max");
+    const transpose = matrix.transpose(simplicialSet);
+    const prodMatrix = matrix.pairwiseMultiply(transpose, simplicialSet);
+    simplicialSet = matrix.add(simplicialSet, matrix.subtract(transpose, prodMatrix));
+    return matrix.eliminateZeros(simplicialSet);
+}
+export function initTransform(indices, weights, embedding) {
+    const result = utils
+        .zeros(indices.length)
+        .map(z => utils.zeros(embedding[0].length));
+    for (let i = 0; i < indices.length; i++) {
+        for (let j = 0; j < indices[0].length; j++) {
+            for (let d = 0; d < embedding[0].length; d++) {
+                const a = indices[i][j];
+                result[i][d] += weights[i][j] * embedding[a][d];
+            }
+        }
+    }
+    return result;
+}