@elarsaks/umap-wasm 0.1.2 → 0.1.4

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

@@ -1,4 +1,4 @@
-import { RandomFn } from './umap';
+import { RandomFn } from './umap.js';
 export type Heap = number[][][];
 export declare function makeHeap(nPoints: number, size: number): Heap;
 export declare function rejectionSample(nSamples: number, poolSize: number, random: RandomFn): number[];

package/dist/heap.js

@@ -0,0 +1,184 @@
+import * as utils from './utils.js';
+export function makeHeap(nPoints, size) {
+    const makeArrays = (fillValue) => {
+        return utils.empty(nPoints).map(() => {
+            return utils.filled(size, fillValue);
+        });
+    };
+    const heap = [];
+    heap.push(makeArrays(-1));
+    heap.push(makeArrays(Infinity));
+    heap.push(makeArrays(0));
+    return heap;
+}
+export function rejectionSample(nSamples, poolSize, random) {
+    const result = utils.zeros(nSamples);
+    for (let i = 0; i < nSamples; i++) {
+        let rejectSample = true;
+        let j = 0;
+        while (rejectSample) {
+            j = utils.tauRandInt(poolSize, random);
+            let broken = false;
+            for (let k = 0; k < i; k++) {
+                if (j === result[k]) {
+                    broken = true;
+                    break;
+                }
+            }
+            if (!broken)
+                rejectSample = false;
+        }
+        result[i] = j;
+    }
+    return result;
+}
+export function heapPush(heap, row, weight, index, flag) {
+    row = Math.floor(row);
+    const indices = heap[0][row];
+    const weights = heap[1][row];
+    const isNew = heap[2][row];
+    if (weight >= weights[0]) {
+        return 0;
+    }
+    for (let i = 0; i < indices.length; i++) {
+        if (index === indices[i]) {
+            return 0;
+        }
+    }
+    return uncheckedHeapPush(heap, row, weight, index, flag);
+}
+export function uncheckedHeapPush(heap, row, weight, index, flag) {
+    const indices = heap[0][row];
+    const weights = heap[1][row];
+    const isNew = heap[2][row];
+    if (weight >= weights[0]) {
+        return 0;
+    }
+    weights[0] = weight;
+    indices[0] = index;
+    isNew[0] = flag;
+    let i = 0;
+    let iSwap = 0;
+    while (true) {
+        const ic1 = 2 * i + 1;
+        const ic2 = ic1 + 1;
+        const heapShape2 = heap[0][0].length;
+        if (ic1 >= heapShape2) {
+            break;
+        }
+        else if (ic2 >= heapShape2) {
+            if (weights[ic1] > weight) {
+                iSwap = ic1;
+            }
+            else {
+                break;
+            }
+        }
+        else if (weights[ic1] >= weights[ic2]) {
+            if (weight < weights[ic1]) {
+                iSwap = ic1;
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            if (weight < weights[ic2]) {
+                iSwap = ic2;
+            }
+            else {
+                break;
+            }
+        }
+        weights[i] = weights[iSwap];
+        indices[i] = indices[iSwap];
+        isNew[i] = isNew[iSwap];
+        i = iSwap;
+    }
+    weights[i] = weight;
+    indices[i] = index;
+    isNew[i] = flag;
+    return 1;
+}
+export function buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random) {
+    const candidateNeighbors = makeHeap(nVertices, maxCandidates);
+    for (let i = 0; i < nVertices; i++) {
+        for (let j = 0; j < nNeighbors; j++) {
+            if (currentGraph[0][i][j] < 0) {
+                continue;
+            }
+            const idx = currentGraph[0][i][j];
+            const isn = currentGraph[2][i][j];
+            const d = utils.tauRand(random);
+            heapPush(candidateNeighbors, i, d, idx, isn);
+            heapPush(candidateNeighbors, idx, d, i, isn);
+            currentGraph[2][i][j] = 0;
+        }
+    }
+    return candidateNeighbors;
+}
+export function deheapSort(heap) {
+    const indices = heap[0];
+    const weights = heap[1];
+    for (let i = 0; i < indices.length; i++) {
+        const indHeap = indices[i];
+        const distHeap = weights[i];
+        for (let j = 0; j < indHeap.length - 1; j++) {
+            const indHeapIndex = indHeap.length - j - 1;
+            const distHeapIndex = distHeap.length - j - 1;
+            const temp1 = indHeap[0];
+            indHeap[0] = indHeap[indHeapIndex];
+            indHeap[indHeapIndex] = temp1;
+            const temp2 = distHeap[0];
+            distHeap[0] = distHeap[distHeapIndex];
+            distHeap[distHeapIndex] = temp2;
+            siftDown(distHeap, indHeap, distHeapIndex, 0);
+        }
+    }
+    return { indices, weights };
+}
+function siftDown(heap1, heap2, ceiling, elt) {
+    while (elt * 2 + 1 < ceiling) {
+        const leftChild = elt * 2 + 1;
+        const rightChild = leftChild + 1;
+        let swap = elt;
+        if (heap1[swap] < heap1[leftChild]) {
+            swap = leftChild;
+        }
+        if (rightChild < ceiling && heap1[swap] < heap1[rightChild]) {
+            swap = rightChild;
+        }
+        if (swap === elt) {
+            break;
+        }
+        else {
+            const temp1 = heap1[elt];
+            heap1[elt] = heap1[swap];
+            heap1[swap] = temp1;
+            const temp2 = heap2[elt];
+            heap2[elt] = heap2[swap];
+            heap2[swap] = temp2;
+            elt = swap;
+        }
+    }
+}
+export function smallestFlagged(heap, row) {
+    const ind = heap[0][row];
+    const dist = heap[1][row];
+    const flag = heap[2][row];
+    let minDist = Infinity;
+    let resultIndex = -1;
+    for (let i = 0; i > ind.length; i++) {
+        if (flag[i] === 1 && dist[i] < minDist) {
+            minDist = dist[i];
+            resultIndex = i;
+        }
+    }
+    if (resultIndex >= 0) {
+        flag[resultIndex] = 0;
+        return Math.floor(ind[resultIndex]);
+    }
+    else {
+        return -1;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { UMAP, UMAPParameters } from './umap.js';
+export { initWasm, isWasmAvailable } from './wasmBridge.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { UMAP } from './umap.js';
+export { initWasm, isWasmAvailable } from './wasmBridge.js';

package/dist/lib.d.ts

@@ -0,0 +1,2 @@
+export { UMAP } from './umap.js';
+export { initWasm, isWasmAvailable } from './wasmBridge.js';

package/dist/lib.js

@@ -0,0 +1,2 @@
+export { UMAP } from './umap.js';
+export { initWasm, isWasmAvailable } from './wasmBridge.js';

package/dist/matrix.js

@@ -0,0 +1,257 @@
+import * as utils from './utils.js';
+export class SparseMatrix {
+    constructor(rows, cols, values, dims) {
+        this.entries = new Map();
+        this.nRows = 0;
+        this.nCols = 0;
+        if (rows.length !== cols.length || rows.length !== values.length) {
+            throw new Error('rows, cols and values arrays must all have the same length');
+        }
+        this.nRows = dims[0];
+        this.nCols = dims[1];
+        for (let i = 0; i < values.length; i++) {
+            const row = rows[i];
+            const col = cols[i];
+            this.checkDims(row, col);
+            const key = this.makeKey(row, col);
+            this.entries.set(key, { value: values[i], row, col });
+        }
+    }
+    makeKey(row, col) {
+        return `${row}:${col}`;
+    }
+    checkDims(row, col) {
+        const withinBounds = row < this.nRows && col < this.nCols;
+        if (!withinBounds) {
+            throw new Error('row and/or col specified outside of matrix dimensions');
+        }
+    }
+    set(row, col, value) {
+        this.checkDims(row, col);
+        const key = this.makeKey(row, col);
+        if (!this.entries.has(key)) {
+            this.entries.set(key, { value, row, col });
+        }
+        else {
+            this.entries.get(key).value = value;
+        }
+    }
+    get(row, col, defaultValue = 0) {
+        this.checkDims(row, col);
+        const key = this.makeKey(row, col);
+        if (this.entries.has(key)) {
+            return this.entries.get(key).value;
+        }
+        else {
+            return defaultValue;
+        }
+    }
+    getAll(ordered = true) {
+        const rowColValues = [];
+        this.entries.forEach(value => {
+            rowColValues.push(value);
+        });
+        if (ordered) {
+            rowColValues.sort((a, b) => {
+                if (a.row === b.row) {
+                    return a.col - b.col;
+                }
+                else {
+                    return a.row - b.row;
+                }
+            });
+        }
+        return rowColValues;
+    }
+    getDims() {
+        return [this.nRows, this.nCols];
+    }
+    getRows() {
+        return Array.from(this.entries, ([key, value]) => value.row);
+    }
+    getCols() {
+        return Array.from(this.entries, ([key, value]) => value.col);
+    }
+    getValues() {
+        return Array.from(this.entries, ([key, value]) => value.value);
+    }
+    forEach(fn) {
+        this.entries.forEach(value => fn(value.value, value.row, value.col));
+    }
+    map(fn) {
+        let vals = [];
+        this.entries.forEach(value => {
+            vals.push(fn(value.value, value.row, value.col));
+        });
+        const dims = [this.nRows, this.nCols];
+        return new SparseMatrix(this.getRows(), this.getCols(), vals, dims);
+    }
+    toArray() {
+        const rows = utils.empty(this.nRows);
+        const output = rows.map(() => {
+            return utils.zeros(this.nCols);
+        });
+        this.entries.forEach(value => {
+            output[value.row][value.col] = value.value;
+        });
+        return output;
+    }
+}
+export function transpose(matrix) {
+    const cols = [];
+    const rows = [];
+    const vals = [];
+    matrix.forEach((value, row, col) => {
+        cols.push(row);
+        rows.push(col);
+        vals.push(value);
+    });
+    const dims = [matrix.nCols, matrix.nRows];
+    return new SparseMatrix(rows, cols, vals, dims);
+}
+export function identity(size) {
+    const [rows] = size;
+    const matrix = new SparseMatrix([], [], [], size);
+    for (let i = 0; i < rows; i++) {
+        matrix.set(i, i, 1);
+    }
+    return matrix;
+}
+export function pairwiseMultiply(a, b) {
+    return elementWise(a, b, (x, y) => x * y);
+}
+export function add(a, b) {
+    return elementWise(a, b, (x, y) => x + y);
+}
+export function subtract(a, b) {
+    return elementWise(a, b, (x, y) => x - y);
+}
+export function maximum(a, b) {
+    return elementWise(a, b, (x, y) => (x > y ? x : y));
+}
+export function multiplyScalar(a, scalar) {
+    return a.map((value) => {
+        return value * scalar;
+    });
+}
+export function eliminateZeros(m) {
+    const zeroIndices = new Set();
+    const values = m.getValues();
+    const rows = m.getRows();
+    const cols = m.getCols();
+    for (let i = 0; i < values.length; i++) {
+        if (values[i] === 0) {
+            zeroIndices.add(i);
+        }
+    }
+    const removeByZeroIndex = (_, index) => !zeroIndices.has(index);
+    const nextValues = values.filter(removeByZeroIndex);
+    const nextRows = rows.filter(removeByZeroIndex);
+    const nextCols = cols.filter(removeByZeroIndex);
+    return new SparseMatrix(nextRows, nextCols, nextValues, m.getDims());
+}
+export function normalize(m, normType = "l2") {
+    const normFn = normFns[normType];
+    const colsByRow = new Map();
+    m.forEach((_, row, col) => {
+        const cols = colsByRow.get(row) || [];
+        cols.push(col);
+        colsByRow.set(row, cols);
+    });
+    const nextMatrix = new SparseMatrix([], [], [], m.getDims());
+    for (let row of colsByRow.keys()) {
+        const cols = colsByRow.get(row).sort();
+        const vals = cols.map(col => m.get(row, col));
+        const norm = normFn(vals);
+        for (let i = 0; i < norm.length; i++) {
+            nextMatrix.set(row, cols[i], norm[i]);
+        }
+    }
+    return nextMatrix;
+}
+const normFns = {
+    ["max"]: (xs) => {
+        let max = -Infinity;
+        for (let i = 0; i < xs.length; i++) {
+            max = xs[i] > max ? xs[i] : max;
+        }
+        return xs.map(x => x / max);
+    },
+    ["l1"]: (xs) => {
+        let sum = 0;
+        for (let i = 0; i < xs.length; i++) {
+            sum += xs[i];
+        }
+        return xs.map(x => x / sum);
+    },
+    ["l2"]: (xs) => {
+        let sum = 0;
+        for (let i = 0; i < xs.length; i++) {
+            sum += xs[i] ** 2;
+        }
+        return xs.map(x => Math.sqrt(x ** 2 / sum));
+    },
+};
+function elementWise(a, b, op) {
+    const visited = new Set();
+    const rows = [];
+    const cols = [];
+    const vals = [];
+    const operate = (row, col) => {
+        rows.push(row);
+        cols.push(col);
+        const nextValue = op(a.get(row, col), b.get(row, col));
+        vals.push(nextValue);
+    };
+    const valuesA = a.getValues();
+    const rowsA = a.getRows();
+    const colsA = a.getCols();
+    for (let i = 0; i < valuesA.length; i++) {
+        const row = rowsA[i];
+        const col = colsA[i];
+        const key = `${row}:${col}`;
+        visited.add(key);
+        operate(row, col);
+    }
+    const valuesB = b.getValues();
+    const rowsB = b.getRows();
+    const colsB = b.getCols();
+    for (let i = 0; i < valuesB.length; i++) {
+        const row = rowsB[i];
+        const col = colsB[i];
+        const key = `${row}:${col}`;
+        if (visited.has(key))
+            continue;
+        operate(row, col);
+    }
+    const dims = [a.nRows, a.nCols];
+    return new SparseMatrix(rows, cols, vals, dims);
+}
+export function getCSR(x) {
+    const entries = [];
+    x.forEach((value, row, col) => {
+        entries.push({ value, row, col });
+    });
+    entries.sort((a, b) => {
+        if (a.row === b.row) {
+            return a.col - b.col;
+        }
+        else {
+            return a.row - b.row;
+        }
+    });
+    const indices = [];
+    const values = [];
+    const indptr = [];
+    let currentRow = -1;
+    for (let i = 0; i < entries.length; i++) {
+        const { row, col, value } = entries[i];
+        if (row !== currentRow) {
+            currentRow = row;
+            indptr.push(i);
+        }
+        indices.push(col);
+        values.push(value);
+    }
+    return { indices, values, indptr };
+}

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

@@ -1,7 +1,7 @@
-import * as heap from './heap';
-import * as matrix from './matrix';
-import * as tree from './tree';
-import { RandomFn, Vectors, DistanceFn } from './umap';
+import * as heap from './heap.js';
+import * as matrix from './matrix.js';
+import * as tree from './tree.js';
+import { RandomFn, Vectors, DistanceFn } from './umap.js';
 export declare function makeNNDescent(distanceFn: DistanceFn, random: RandomFn): (data: Vectors, leafArray: Vectors, nNeighbors: number, nIters?: number, maxCandidates?: number, delta?: number, rho?: number, rpTreeInit?: boolean) => {
     indices: number[][];
     weights: number[][];

package/dist/nn_descent.js

@@ -0,0 +1,127 @@
+import * as heap from './heap.js';
+import * as matrix from './matrix.js';
+import * as tree from './tree.js';
+import * as utils from './utils.js';
+export function makeNNDescent(distanceFn, random) {
+    return function nNDescent(data, leafArray, nNeighbors, nIters = 10, maxCandidates = 50, delta = 0.001, rho = 0.5, rpTreeInit = true) {
+        const nVertices = data.length;
+        const currentGraph = heap.makeHeap(data.length, nNeighbors);
+        for (let i = 0; i < data.length; i++) {
+            const indices = heap.rejectionSample(nNeighbors, data.length, random);
+            for (let j = 0; j < indices.length; j++) {
+                const 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 (let n = 0; n < leafArray.length; n++) {
+                for (let i = 0; i < leafArray[n].length; i++) {
+                    if (leafArray[n][i] < 0) {
+                        break;
+                    }
+                    for (let j = i + 1; j < leafArray[n].length; j++) {
+                        if (leafArray[n][j] < 0) {
+                            break;
+                        }
+                        const 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 (let n = 0; n < nIters; n++) {
+            const candidateNeighbors = heap.buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random);
+            let c = 0;
+            for (let i = 0; i < nVertices; i++) {
+                for (let j = 0; j < maxCandidates; j++) {
+                    let p = Math.floor(candidateNeighbors[0][i][j]);
+                    if (p < 0 || utils.tauRand(random) < rho) {
+                        continue;
+                    }
+                    for (let k = 0; k < maxCandidates; k++) {
+                        const q = Math.floor(candidateNeighbors[0][i][k]);
+                        const cj = candidateNeighbors[2][i][j];
+                        const ck = candidateNeighbors[2][i][k];
+                        if (q < 0 || (!cj && !ck)) {
+                            continue;
+                        }
+                        const 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;
+            }
+        }
+        const sorted = heap.deheapSort(currentGraph);
+        return sorted;
+    };
+}
+export function makeInitializations(distanceFn) {
+    function initFromRandom(nNeighbors, data, queryPoints, _heap, random) {
+        for (let i = 0; i < queryPoints.length; i++) {
+            const indices = utils.rejectionSample(nNeighbors, data.length, random);
+            for (let j = 0; j < indices.length; j++) {
+                if (indices[j] < 0) {
+                    continue;
+                }
+                const d = distanceFn(data[indices[j]], queryPoints[i]);
+                heap.heapPush(_heap, i, d, indices[j], 1);
+            }
+        }
+    }
+    function initFromTree(_tree, data, queryPoints, _heap, random) {
+        for (let i = 0; i < queryPoints.length; i++) {
+            const indices = tree.searchFlatTree(queryPoints[i], _tree, random);
+            for (let j = 0; j < indices.length; j++) {
+                if (indices[j] < 0) {
+                    return;
+                }
+                const d = distanceFn(data[indices[j]], queryPoints[i]);
+                heap.heapPush(_heap, i, d, indices[j], 1);
+            }
+        }
+        return;
+    }
+    return { initFromRandom, initFromTree };
+}
+export function makeInitializedNNSearch(distanceFn) {
+    return function nnSearchFn(data, graph, initialization, queryPoints) {
+        const { indices, indptr } = matrix.getCSR(graph);
+        for (let i = 0; i < queryPoints.length; i++) {
+            const tried = new Set(initialization[0][i]);
+            while (true) {
+                const vertex = heap.smallestFlagged(initialization, i);
+                if (vertex === -1) {
+                    break;
+                }
+                const candidates = indices.slice(indptr[vertex], indptr[vertex + 1]);
+                for (const candidate of candidates) {
+                    if (candidate === vertex ||
+                        candidate === -1 ||
+                        tried.has(candidate)) {
+                        continue;
+                    }
+                    const d = distanceFn(data[candidate], queryPoints[i]);
+                    heap.uncheckedHeapPush(initialization, i, d, candidate, 1);
+                    tried.add(candidate);
+                }
+            }
+        }
+        return initialization;
+    };
+}
+export function initializeSearch(forest, data, queryPoints, nNeighbors, initFromRandom, initFromTree, random) {
+    const results = heap.makeHeap(queryPoints.length, nNeighbors);
+    initFromRandom(nNeighbors, data, queryPoints, results, random);
+    if (forest) {
+        for (let tree of forest) {
+            initFromTree(tree, data, queryPoints, results, random);
+        }
+    }
+    return results;
+}

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

@@ -1,5 +1,5 @@
-import { RandomFn, Vector, Vectors } from './umap';
-import { WasmFlatTree } from './wasmBridge';
+import { RandomFn, Vector, Vectors } from './umap.js';
+import { WasmFlatTree } from './wasmBridge.js';
 export declare class FlatTree {
     hyperplanes: number[][];
     offsets: number[];