@elarsaks/umap-wasm 0.1.2 → 0.1.4

package/dist/tree.js

@@ -0,0 +1,228 @@
+import * as utils from './utils.js';
+import { isWasmAvailable, buildRpTreeWasm, searchFlatTreeWasm, wasmTreeToJs } from './wasmBridge.js';
+export class FlatTree {
+    constructor(hyperplanes, offsets, children, indices) {
+        this.hyperplanes = hyperplanes;
+        this.offsets = offsets;
+        this.children = children;
+        this.indices = indices;
+    }
+    static fromWasm(wasmTree) {
+        const jsData = wasmTreeToJs(wasmTree);
+        const tree = new FlatTree(jsData.hyperplanes, jsData.offsets, jsData.children, jsData.indices);
+        tree.wasmTree = wasmTree;
+        return tree;
+    }
+    getWasmTree() {
+        return this.wasmTree;
+    }
+    dispose() {
+        if (this.wasmTree) {
+            this.wasmTree.free();
+            this.wasmTree = undefined;
+        }
+    }
+}
+export function makeForest(data, nNeighbors, nTrees, random, useWasm = false) {
+    const leafSize = Math.max(10, nNeighbors);
+    if (useWasm) {
+        if (!isWasmAvailable()) {
+            throw new Error('WASM requested but not available');
+        }
+        return makeForestWasm(data, leafSize, nTrees, random);
+    }
+    const trees = utils
+        .range(nTrees)
+        .map((_, i) => makeTree(data, leafSize, i, random));
+    const forest = trees.map(tree => flattenTree(tree, leafSize));
+    return forest;
+}
+function makeForestWasm(data, leafSize, nTrees, random) {
+    const nSamples = data.length;
+    const dim = data[0].length;
+    const forest = [];
+    for (let i = 0; i < nTrees; i++) {
+        const seed = Math.floor(random() * 0xFFFFFFFF);
+        const wasmTree = buildRpTreeWasm(data, nSamples, dim, leafSize, seed);
+        forest.push(FlatTree.fromWasm(wasmTree));
+    }
+    return forest;
+}
+function makeTree(data, leafSize = 30, n, random) {
+    const indices = utils.range(data.length);
+    const tree = makeEuclideanTree(data, indices, leafSize, n, random);
+    return tree;
+}
+function makeEuclideanTree(data, indices, leafSize = 30, q, random) {
+    if (indices.length > leafSize) {
+        const splitResults = euclideanRandomProjectionSplit(data, indices, random);
+        const { indicesLeft, indicesRight, hyperplane, offset } = splitResults;
+        const leftChild = makeEuclideanTree(data, indicesLeft, leafSize, q + 1, random);
+        const rightChild = makeEuclideanTree(data, indicesRight, leafSize, q + 1, random);
+        const node = { leftChild, rightChild, isLeaf: false, hyperplane, offset };
+        return node;
+    }
+    else {
+        const node = { indices, isLeaf: true };
+        return node;
+    }
+}
+function euclideanRandomProjectionSplit(data, indices, random) {
+    const dim = data[0].length;
+    let leftIndex = utils.tauRandInt(indices.length, random);
+    let rightIndex = utils.tauRandInt(indices.length, random);
+    rightIndex += leftIndex === rightIndex ? 1 : 0;
+    rightIndex = rightIndex % indices.length;
+    const left = indices[leftIndex];
+    const right = indices[rightIndex];
+    let hyperplaneOffset = 0;
+    const hyperplaneVector = utils.zeros(dim);
+    for (let 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;
+    }
+    let nLeft = 0;
+    let nRight = 0;
+    const side = utils.zeros(indices.length);
+    for (let i = 0; i < indices.length; i++) {
+        let margin = hyperplaneOffset;
+        for (let 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;
+        }
+    }
+    const indicesLeft = utils.zeros(nLeft);
+    const indicesRight = utils.zeros(nRight);
+    nLeft = 0;
+    nRight = 0;
+    for (let 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,
+        indicesRight,
+        hyperplane: hyperplaneVector,
+        offset: hyperplaneOffset,
+    };
+}
+function flattenTree(tree, leafSize) {
+    const nNodes = numNodes(tree);
+    const nLeaves = numLeaves(tree);
+    const hyperplanes = utils
+        .range(nNodes)
+        .map(() => utils.zeros(tree.hyperplane ? tree.hyperplane.length : 0));
+    const offsets = utils.zeros(nNodes);
+    const children = utils.range(nNodes).map(() => [-1, -1]);
+    const indices = utils
+        .range(nLeaves)
+        .map(() => utils.range(leafSize).map(() => -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) {
+    if (tree.isLeaf) {
+        children[nodeNum][0] = -leafNum;
+        indices[leafNum].splice(0, tree.indices.length, ...tree.indices);
+        leafNum += 1;
+        return { nodeNum, leafNum };
+    }
+    else {
+        hyperplanes[nodeNum] = tree.hyperplane;
+        offsets[nodeNum] = tree.offset;
+        children[nodeNum][0] = nodeNum + 1;
+        const oldNodeNum = nodeNum;
+        let 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);
+    }
+}
+export function makeLeafArray(rpForest) {
+    if (rpForest.length > 0) {
+        const output = [];
+        for (let tree of rpForest) {
+            output.push(...tree.indices);
+        }
+        return output;
+    }
+    else {
+        return [[-1]];
+    }
+}
+function selectSide(hyperplane, offset, point, random) {
+    let margin = offset;
+    for (let d = 0; d < point.length; d++) {
+        margin += hyperplane[d] * point[d];
+    }
+    if (margin === 0) {
+        const side = utils.tauRandInt(2, random);
+        return side;
+    }
+    else if (margin > 0) {
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}
+export function searchFlatTree(point, tree, random) {
+    const wasmTree = tree.getWasmTree();
+    if (wasmTree && isWasmAvailable()) {
+        const seed = Math.floor(random() * 0xFFFFFFFF);
+        return searchFlatTreeWasm(wasmTree, point, seed);
+    }
+    let node = 0;
+    while (tree.children[node][0] > 0) {
+        const side = selectSide(tree.hyperplanes[node], tree.offsets[node], point, random);
+        if (side === 0) {
+            node = tree.children[node][0];
+        }
+        else {
+            node = tree.children[node][1];
+        }
+    }
+    const index = -1 * tree.children[node][0];
+    return tree.indices[index];
+}

package/dist/{src/umap.d.ts → umap.d.ts}

@@ -1,4 +1,4 @@
-import * as matrix from './matrix';
+import * as matrix from './matrix.js';
 export type DistanceFn = (x: Vector, y: Vector) => number;
 export type RandomFn = () => number;
 export type EpochCallback = (epoch: number) => boolean | void;