@elarsaks/umap-wasm 0.1.0

package/dist/src/nn_descent.js

@@ -0,0 +1,204 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNNDescent = makeNNDescent;
+exports.makeInitializations = makeInitializations;
+exports.makeInitializedNNSearch = makeInitializedNNSearch;
+exports.initializeSearch = initializeSearch;
+var heap = __importStar(require("./heap"));
+var matrix = __importStar(require("./matrix"));
+var tree = __importStar(require("./tree"));
+var utils = __importStar(require("./utils"));
+function makeNNDescent(distanceFn, random) {
+    return function nNDescent(data, leafArray, nNeighbors, nIters, maxCandidates, delta, rho, rpTreeInit) {
+        if (nIters === void 0) { nIters = 10; }
+        if (maxCandidates === void 0) { maxCandidates = 50; }
+        if (delta === void 0) { delta = 0.001; }
+        if (rho === void 0) { rho = 0.5; }
+        if (rpTreeInit === void 0) { rpTreeInit = true; }
+        var nVertices = data.length;
+        var currentGraph = heap.makeHeap(data.length, nNeighbors);
+        for (var i = 0; i < data.length; i++) {
+            var indices = heap.rejectionSample(nNeighbors, data.length, random);
+            for (var j = 0; j < indices.length; j++) {
+                var d = distanceFn(data[i], data[indices[j]]);
+                heap.heapPush(currentGraph, i, d, indices[j], 1);
+                heap.heapPush(currentGraph, indices[j], d, i, 1);
+            }
+        }
+        if (rpTreeInit) {
+            for (var n = 0; n < leafArray.length; n++) {
+                for (var i = 0; i < leafArray[n].length; i++) {
+                    if (leafArray[n][i] < 0) {
+                        break;
+                    }
+                    for (var j = i + 1; j < leafArray[n].length; j++) {
+                        if (leafArray[n][j] < 0) {
+                            break;
+                        }
+                        var d = distanceFn(data[leafArray[n][i]], data[leafArray[n][j]]);
+                        heap.heapPush(currentGraph, leafArray[n][i], d, leafArray[n][j], 1);
+                        heap.heapPush(currentGraph, leafArray[n][j], d, leafArray[n][i], 1);
+                    }
+                }
+            }
+        }
+        for (var n = 0; n < nIters; n++) {
+            var candidateNeighbors = heap.buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random);
+            var c = 0;
+            for (var i = 0; i < nVertices; i++) {
+                for (var j = 0; j < maxCandidates; j++) {
+                    var p = Math.floor(candidateNeighbors[0][i][j]);
+                    if (p < 0 || utils.tauRand(random) < rho) {
+                        continue;
+                    }
+                    for (var k = 0; k < maxCandidates; k++) {
+                        var q = Math.floor(candidateNeighbors[0][i][k]);
+                        var cj = candidateNeighbors[2][i][j];
+                        var ck = candidateNeighbors[2][i][k];
+                        if (q < 0 || (!cj && !ck)) {
+                            continue;
+                        }
+                        var d = distanceFn(data[p], data[q]);
+                        c += heap.heapPush(currentGraph, p, d, q, 1);
+                        c += heap.heapPush(currentGraph, q, d, p, 1);
+                    }
+                }
+            }
+            if (c <= delta * nNeighbors * data.length) {
+                break;
+            }
+        }
+        var sorted = heap.deheapSort(currentGraph);
+        return sorted;
+    };
+}
+function makeInitializations(distanceFn) {
+    function initFromRandom(nNeighbors, data, queryPoints, _heap, random) {
+        for (var i = 0; i < queryPoints.length; i++) {
+            var indices = utils.rejectionSample(nNeighbors, data.length, random);
+            for (var j = 0; j < indices.length; j++) {
+                if (indices[j] < 0) {
+                    continue;
+                }
+                var d = distanceFn(data[indices[j]], queryPoints[i]);
+                heap.heapPush(_heap, i, d, indices[j], 1);
+            }
+        }
+    }
+    function initFromTree(_tree, data, queryPoints, _heap, random) {
+        for (var i = 0; i < queryPoints.length; i++) {
+            var indices = tree.searchFlatTree(queryPoints[i], _tree, random);
+            for (var j = 0; j < indices.length; j++) {
+                if (indices[j] < 0) {
+                    return;
+                }
+                var d = distanceFn(data[indices[j]], queryPoints[i]);
+                heap.heapPush(_heap, i, d, indices[j], 1);
+            }
+        }
+        return;
+    }
+    return { initFromRandom: initFromRandom, initFromTree: initFromTree };
+}
+function makeInitializedNNSearch(distanceFn) {
+    return function nnSearchFn(data, graph, initialization, queryPoints) {
+        var e_1, _a;
+        var _b = matrix.getCSR(graph), indices = _b.indices, indptr = _b.indptr;
+        for (var i = 0; i < queryPoints.length; i++) {
+            var tried = new Set(initialization[0][i]);
+            while (true) {
+                var vertex = heap.smallestFlagged(initialization, i);
+                if (vertex === -1) {
+                    break;
+                }
+                var candidates = indices.slice(indptr[vertex], indptr[vertex + 1]);
+                try {
+                    for (var candidates_1 = (e_1 = void 0, __values(candidates)), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+                        var candidate = candidates_1_1.value;
+                        if (candidate === vertex ||
+                            candidate === -1 ||
+                            tried.has(candidate)) {
+                            continue;
+                        }
+                        var d = distanceFn(data[candidate], queryPoints[i]);
+                        heap.uncheckedHeapPush(initialization, i, d, candidate, 1);
+                        tried.add(candidate);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+        }
+        return initialization;
+    };
+}
+function initializeSearch(forest, data, queryPoints, nNeighbors, initFromRandom, initFromTree, random) {
+    var e_2, _a;
+    var results = heap.makeHeap(queryPoints.length, nNeighbors);
+    initFromRandom(nNeighbors, data, queryPoints, results, random);
+    if (forest) {
+        try {
+            for (var forest_1 = __values(forest), forest_1_1 = forest_1.next(); !forest_1_1.done; forest_1_1 = forest_1.next()) {
+                var tree_1 = forest_1_1.value;
+                initFromTree(tree_1, data, queryPoints, results, random);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (forest_1_1 && !forest_1_1.done && (_a = forest_1.return)) _a.call(forest_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+    return results;
+}

package/dist/src/tree.d.ts

@@ -0,0 +1,16 @@
+import { RandomFn, Vector, Vectors } from './umap';
+import { WasmFlatTree } from './wasmBridge';
+export declare class FlatTree {
+    hyperplanes: number[][];
+    offsets: number[];
+    children: number[][];
+    indices: number[][];
+    private wasmTree?;
+    constructor(hyperplanes: number[][], offsets: number[], children: number[][], indices: number[][]);
+    static fromWasm(wasmTree: WasmFlatTree): FlatTree;
+    getWasmTree(): WasmFlatTree | undefined;
+    dispose(): void;
+}
+export declare function makeForest(data: Vectors, nNeighbors: number, nTrees: number, random: RandomFn, useWasm?: boolean): FlatTree[];
+export declare function makeLeafArray(rpForest: FlatTree[]): number[][];
+export declare function searchFlatTree(point: Vector, tree: FlatTree, random: RandomFn): number[];

package/dist/src/tree.js

@@ -0,0 +1,320 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlatTree = void 0;
+exports.makeForest = makeForest;
+exports.makeLeafArray = makeLeafArray;
+exports.searchFlatTree = searchFlatTree;
+var utils = __importStar(require("./utils"));
+var wasmBridge_1 = require("./wasmBridge");
+var FlatTree = (function () {
+    function FlatTree(hyperplanes, offsets, children, indices) {
+        this.hyperplanes = hyperplanes;
+        this.offsets = offsets;
+        this.children = children;
+        this.indices = indices;
+    }
+    FlatTree.fromWasm = function (wasmTree) {
+        var jsData = (0, wasmBridge_1.wasmTreeToJs)(wasmTree);
+        var tree = new FlatTree(jsData.hyperplanes, jsData.offsets, jsData.children, jsData.indices);
+        tree.wasmTree = wasmTree;
+        return tree;
+    };
+    FlatTree.prototype.getWasmTree = function () {
+        return this.wasmTree;
+    };
+    FlatTree.prototype.dispose = function () {
+        if (this.wasmTree) {
+            this.wasmTree.free();
+            this.wasmTree = undefined;
+        }
+    };
+    return FlatTree;
+}());
+exports.FlatTree = FlatTree;
+function makeForest(data, nNeighbors, nTrees, random, useWasm) {
+    if (useWasm === void 0) { useWasm = false; }
+    var leafSize = Math.max(10, nNeighbors);
+    if (useWasm) {
+        if (!(0, wasmBridge_1.isWasmAvailable)()) {
+            throw new Error('WASM requested but not available');
+        }
+        return makeForestWasm(data, leafSize, nTrees, random);
+    }
+    var trees = utils
+        .range(nTrees)
+        .map(function (_, i) { return makeTree(data, leafSize, i, random); });
+    var forest = trees.map(function (tree) { return flattenTree(tree, leafSize); });
+    return forest;
+}
+function makeForestWasm(data, leafSize, nTrees, random) {
+    var nSamples = data.length;
+    var dim = data[0].length;
+    var forest = [];
+    for (var i = 0; i < nTrees; i++) {
+        var seed = Math.floor(random() * 0xFFFFFFFF);
+        var wasmTree = (0, wasmBridge_1.buildRpTreeWasm)(data, nSamples, dim, leafSize, seed);
+        forest.push(FlatTree.fromWasm(wasmTree));
+    }
+    return forest;
+}
+function makeTree(data, leafSize, n, random) {
+    if (leafSize === void 0) { leafSize = 30; }
+    var indices = utils.range(data.length);
+    var tree = makeEuclideanTree(data, indices, leafSize, n, random);
+    return tree;
+}
+function makeEuclideanTree(data, indices, leafSize, q, random) {
+    if (leafSize === void 0) { leafSize = 30; }
+    if (indices.length > leafSize) {
+        var splitResults = euclideanRandomProjectionSplit(data, indices, random);
+        var indicesLeft = splitResults.indicesLeft, indicesRight = splitResults.indicesRight, hyperplane = splitResults.hyperplane, offset = splitResults.offset;
+        var leftChild = makeEuclideanTree(data, indicesLeft, leafSize, q + 1, random);
+        var rightChild = makeEuclideanTree(data, indicesRight, leafSize, q + 1, random);
+        var node = { leftChild: leftChild, rightChild: rightChild, isLeaf: false, hyperplane: hyperplane, offset: offset };
+        return node;
+    }
+    else {
+        var node = { indices: indices, isLeaf: true };
+        return node;
+    }
+}
+function euclideanRandomProjectionSplit(data, indices, random) {
+    var dim = data[0].length;
+    var leftIndex = utils.tauRandInt(indices.length, random);
+    var rightIndex = utils.tauRandInt(indices.length, random);
+    rightIndex += leftIndex === rightIndex ? 1 : 0;
+    rightIndex = rightIndex % indices.length;
+    var left = indices[leftIndex];
+    var right = indices[rightIndex];
+    var hyperplaneOffset = 0;
+    var hyperplaneVector = utils.zeros(dim);
+    for (var i = 0; i < hyperplaneVector.length; i++) {
+        hyperplaneVector[i] = data[left][i] - data[right][i];
+        hyperplaneOffset -=
+            (hyperplaneVector[i] * (data[left][i] + data[right][i])) / 2.0;
+    }
+    var nLeft = 0;
+    var nRight = 0;
+    var side = utils.zeros(indices.length);
+    for (var i = 0; i < indices.length; i++) {
+        var margin = hyperplaneOffset;
+        for (var d = 0; d < dim; d++) {
+            margin += hyperplaneVector[d] * data[indices[i]][d];
+        }
+        if (margin === 0) {
+            side[i] = utils.tauRandInt(2, random);
+            if (side[i] === 0) {
+                nLeft += 1;
+            }
+            else {
+                nRight += 1;
+            }
+        }
+        else if (margin > 0) {
+            side[i] = 0;
+            nLeft += 1;
+        }
+        else {
+            side[i] = 1;
+            nRight += 1;
+        }
+    }
+    var indicesLeft = utils.zeros(nLeft);
+    var indicesRight = utils.zeros(nRight);
+    nLeft = 0;
+    nRight = 0;
+    for (var i = 0; i < side.length; i++) {
+        if (side[i] === 0) {
+            indicesLeft[nLeft] = indices[i];
+            nLeft += 1;
+        }
+        else {
+            indicesRight[nRight] = indices[i];
+            nRight += 1;
+        }
+    }
+    return {
+        indicesLeft: indicesLeft,
+        indicesRight: indicesRight,
+        hyperplane: hyperplaneVector,
+        offset: hyperplaneOffset,
+    };
+}
+function flattenTree(tree, leafSize) {
+    var nNodes = numNodes(tree);
+    var nLeaves = numLeaves(tree);
+    var hyperplanes = utils
+        .range(nNodes)
+        .map(function () { return utils.zeros(tree.hyperplane ? tree.hyperplane.length : 0); });
+    var offsets = utils.zeros(nNodes);
+    var children = utils.range(nNodes).map(function () { return [-1, -1]; });
+    var indices = utils
+        .range(nLeaves)
+        .map(function () { return utils.range(leafSize).map(function () { return -1; }); });
+    recursiveFlatten(tree, hyperplanes, offsets, children, indices, 0, 0);
+    return new FlatTree(hyperplanes, offsets, children, indices);
+}
+function recursiveFlatten(tree, hyperplanes, offsets, children, indices, nodeNum, leafNum) {
+    var _a;
+    if (tree.isLeaf) {
+        children[nodeNum][0] = -leafNum;
+        (_a = indices[leafNum]).splice.apply(_a, __spreadArray([0, tree.indices.length], __read(tree.indices), false));
+        leafNum += 1;
+        return { nodeNum: nodeNum, leafNum: leafNum };
+    }
+    else {
+        hyperplanes[nodeNum] = tree.hyperplane;
+        offsets[nodeNum] = tree.offset;
+        children[nodeNum][0] = nodeNum + 1;
+        var oldNodeNum = nodeNum;
+        var res = recursiveFlatten(tree.leftChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);
+        nodeNum = res.nodeNum;
+        leafNum = res.leafNum;
+        children[oldNodeNum][1] = nodeNum + 1;
+        res = recursiveFlatten(tree.rightChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);
+        return { nodeNum: res.nodeNum, leafNum: res.leafNum };
+    }
+}
+function numNodes(tree) {
+    if (tree.isLeaf) {
+        return 1;
+    }
+    else {
+        return 1 + numNodes(tree.leftChild) + numNodes(tree.rightChild);
+    }
+}
+function numLeaves(tree) {
+    if (tree.isLeaf) {
+        return 1;
+    }
+    else {
+        return numLeaves(tree.leftChild) + numLeaves(tree.rightChild);
+    }
+}
+function makeLeafArray(rpForest) {
+    var e_1, _a;
+    if (rpForest.length > 0) {
+        var output = [];
+        try {
+            for (var rpForest_1 = __values(rpForest), rpForest_1_1 = rpForest_1.next(); !rpForest_1_1.done; rpForest_1_1 = rpForest_1.next()) {
+                var tree = rpForest_1_1.value;
+                output.push.apply(output, __spreadArray([], __read(tree.indices), false));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (rpForest_1_1 && !rpForest_1_1.done && (_a = rpForest_1.return)) _a.call(rpForest_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return output;
+    }
+    else {
+        return [[-1]];
+    }
+}
+function selectSide(hyperplane, offset, point, random) {
+    var margin = offset;
+    for (var d = 0; d < point.length; d++) {
+        margin += hyperplane[d] * point[d];
+    }
+    if (margin === 0) {
+        var side = utils.tauRandInt(2, random);
+        return side;
+    }
+    else if (margin > 0) {
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}
+function searchFlatTree(point, tree, random) {
+    var wasmTree = tree.getWasmTree();
+    if (wasmTree && (0, wasmBridge_1.isWasmAvailable)()) {
+        var seed = Math.floor(random() * 0xFFFFFFFF);
+        return (0, wasmBridge_1.searchFlatTreeWasm)(wasmTree, point, seed);
+    }
+    var node = 0;
+    while (tree.children[node][0] > 0) {
+        var side = selectSide(tree.hyperplanes[node], tree.offsets[node], point, random);
+        if (side === 0) {
+            node = tree.children[node][0];
+        }
+        else {
+            node = tree.children[node][1];
+        }
+    }
+    var index = -1 * tree.children[node][0];
+    return tree.indices[index];
+}

package/dist/src/umap.d.ts

@@ -0,0 +1,102 @@
+import * as matrix from './matrix';
+export type DistanceFn = (x: Vector, y: Vector) => number;
+export type RandomFn = () => number;
+export type EpochCallback = (epoch: number) => boolean | void;
+export type Vector = number[];
+export type Vectors = Vector[];
+export declare const enum TargetMetric {
+    categorical = "categorical",
+    l1 = "l1",
+    l2 = "l2"
+}
+export interface UMAPParameters {
+    distanceFn?: DistanceFn;
+    useWasmDistance?: boolean;
+    learningRate?: number;
+    localConnectivity?: number;
+    minDist?: number;
+    nComponents?: number;
+    nEpochs?: number;
+    nNeighbors?: number;
+    negativeSampleRate?: number;
+    repulsionStrength?: number;
+    random?: RandomFn;
+    setOpMixRatio?: number;
+    spread?: number;
+    transformQueueSize?: number;
+}
+export interface UMAPSupervisedParams {
+    targetMetric?: TargetMetric;
+    targetWeight?: number;
+    targetNNeighbors?: number;
+}
+export declare class UMAP {
+    private learningRate;
+    private localConnectivity;
+    private minDist;
+    private nComponents;
+    private nEpochs;
+    private nNeighbors;
+    private negativeSampleRate;
+    private random;
+    private repulsionStrength;
+    private setOpMixRatio;
+    private spread;
+    private transformQueueSize;
+    private targetMetric;
+    private targetWeight;
+    private targetNNeighbors;
+    private distanceFn;
+    private useWasmDistance;
+    private useWasmMatrix;
+    private useWasmTree;
+    private knnIndices?;
+    private knnDistances?;
+    private graph;
+    private X;
+    private isInitialized;
+    private rpForest;
+    private initFromRandom;
+    private initFromTree;
+    private search;
+    private searchGraph;
+    private Y?;
+    private embedding;
+    private optimizationState;
+    constructor(params?: UMAPParameters);
+    fit(X: Vectors): number[][];
+    fitAsync(X: Vectors, callback?: (epochNumber: number) => void | boolean): Promise<number[][]>;
+    setSupervisedProjection(Y: number[], params?: UMAPSupervisedParams): void;
+    setPrecomputedKNN(knnIndices: number[][], knnDistances: number[][]): void;
+    initializeFit(X: Vectors): number;
+    private makeSearchFns;
+    computeDistance(a: Vector, b: Vector): any;
+    private makeSearchGraph;
+    transform(toTransform: Vectors): Vectors;
+    private processGraphForSupervisedProjection;
+    step(): number;
+    getEmbedding(): number[][];
+    private nearestNeighbors;
+    private fuzzySimplicialSet;
+    private categoricalSimplicialSetIntersection;
+    private smoothKNNDistance;
+    private computeMembershipStrengths;
+    private initializeSimplicialSetEmbedding;
+    private makeEpochsPerSample;
+    private assignOptimizationStateParameters;
+    private prepareForOptimizationLoop;
+    private initializeOptimization;
+    private optimizeLayoutStep;
+    private optimizeLayoutAsync;
+    private optimizeLayout;
+    private getNEpochs;
+}
+export declare function euclidean(x: Vector, y: Vector): number;
+export declare function cosine(x: Vector, y: Vector): number;
+export declare function findABParams(spread: number, minDist: number): {
+    a: number;
+    b: number;
+};
+export declare function fastIntersection(graph: matrix.SparseMatrix, target: number[], unknownDist?: number, farDist?: number): matrix.SparseMatrix;
+export declare function resetLocalConnectivity(simplicialSet: matrix.SparseMatrix): matrix.SparseMatrix;
+export declare function initTransform(indices: number[][], weights: number[][], embedding: Vectors): number[][];