@elarsaks/umap-wasm 0.1.2 → 0.1.4

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

@@ -1,4 +1,4 @@
-import { RandomFn } from './umap';
+import { RandomFn } from './umap.js';
 export declare function tauRandInt(n: number, random: RandomFn): number;
 export declare function tauRand(random: RandomFn): number;
 export declare function norm(vec: number[]): number;

package/dist/utils.js

@@ -0,0 +1,98 @@
+export function tauRandInt(n, random) {
+    return Math.floor(random() * n);
+}
+export function tauRand(random) {
+    return random();
+}
+export function norm(vec) {
+    let result = 0;
+    for (let item of vec) {
+        result += item ** 2;
+    }
+    return Math.sqrt(result);
+}
+export function empty(n) {
+    const output = [];
+    for (let i = 0; i < n; i++) {
+        output.push(undefined);
+    }
+    return output;
+}
+export function range(n) {
+    return empty(n).map((_, i) => i);
+}
+export function filled(n, v) {
+    return empty(n).map(() => v);
+}
+export function zeros(n) {
+    return filled(n, 0);
+}
+export function ones(n) {
+    return filled(n, 1);
+}
+export function linear(a, b, len) {
+    return empty(len).map((_, i) => {
+        return a + i * ((b - a) / (len - 1));
+    });
+}
+export function sum(input) {
+    return input.reduce((sum, val) => sum + val);
+}
+export function mean(input) {
+    return sum(input) / input.length;
+}
+export function max(input) {
+    let max = 0;
+    for (let i = 0; i < input.length; i++) {
+        max = input[i] > max ? input[i] : max;
+    }
+    return max;
+}
+export function max2d(input) {
+    let max = 0;
+    for (let i = 0; i < input.length; i++) {
+        for (let j = 0; j < input[i].length; j++) {
+            max = input[i][j] > max ? input[i][j] : max;
+        }
+    }
+    return max;
+}
+export function rejectionSample(nSamples, poolSize, random) {
+    const result = zeros(nSamples);
+    for (let i = 0; i < nSamples; i++) {
+        let rejectSample = true;
+        while (rejectSample) {
+            const j = 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 reshape2d(x, a, b) {
+    const rows = [];
+    let count = 0;
+    let index = 0;
+    if (x.length !== a * b) {
+        throw new Error('Array dimensions must match input length.');
+    }
+    for (let i = 0; i < a; i++) {
+        const col = [];
+        for (let j = 0; j < b; j++) {
+            col.push(x[index]);
+            index += 1;
+        }
+        rows.push(col);
+        count += 1;
+    }
+    return rows;
+}

package/dist/wasmBridge.js

@@ -0,0 +1,188 @@
+let wasmReady = null;
+let wasmModule = null;
+export async function initWasm() {
+    if (wasmReady)
+        return wasmReady;
+    wasmReady = (async () => {
+        try {
+            const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+            const wasmPath = isNode
+                ? '../wasm/pkg/node/umap_wasm_core.js'
+                : '../wasm/pkg/web/umap_wasm_core.js';
+            const mod = await import(wasmPath);
+            if (typeof mod.default === 'function') {
+                await mod.default();
+            }
+            wasmModule = mod;
+            return mod;
+        }
+        catch (err) {
+            wasmReady = null;
+            wasmModule = null;
+            throw new Error(`Failed to load WASM module: ${err}`);
+        }
+    })();
+    return wasmReady;
+}
+export function isWasmAvailable() {
+    return wasmModule !== null;
+}
+export function euclideanWasm(x, y) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    const xa = new Float64Array(x);
+    const ya = new Float64Array(y);
+    return wasmModule.euclidean(xa, ya);
+}
+export function cosineWasm(x, y) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    const xa = new Float64Array(x);
+    const ya = new Float64Array(y);
+    return wasmModule.cosine(xa, ya);
+}
+export function buildRpTreeWasm(data, nSamples, dim, leafSize, seed) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    const flatData = new Float64Array(nSamples * dim);
+    for (let i = 0; i < nSamples; i++) {
+        for (let j = 0; j < dim; j++) {
+            flatData[i * dim + j] = data[i][j];
+        }
+    }
+    return wasmModule.build_rp_tree(flatData, nSamples, dim, leafSize, BigInt(seed));
+}
+export function searchFlatTreeWasm(tree, point, seed) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    const pointArray = new Float64Array(point);
+    const result = wasmModule.search_flat_tree(tree, pointArray, BigInt(seed));
+    return Array.from(result);
+}
+export function wasmTreeToJs(wasmTree) {
+    const hyperplanesFlat = Array.from(wasmTree.hyperplanes());
+    const offsetsArray = Array.from(wasmTree.offsets());
+    const childrenFlat = Array.from(wasmTree.children());
+    const indicesFlat = Array.from(wasmTree.indices());
+    const dim = wasmTree.dim();
+    const nNodes = wasmTree.n_nodes();
+    const hyperplanes = [];
+    for (let i = 0; i < nNodes; i++) {
+        hyperplanes.push(hyperplanesFlat.slice(i * dim, (i + 1) * dim));
+    }
+    const children = [];
+    for (let i = 0; i < nNodes; i++) {
+        children.push([childrenFlat[i * 2], childrenFlat[i * 2 + 1]]);
+    }
+    let maxLeafIdx = 0;
+    for (let i = 0; i < childrenFlat.length; i++) {
+        const v = childrenFlat[i];
+        if (v <= 0) {
+            const leafIdx = -v;
+            if (leafIdx > maxLeafIdx)
+                maxLeafIdx = leafIdx;
+        }
+    }
+    const nLeaves = maxLeafIdx + 1;
+    const leafSize = nLeaves > 0 ? Math.floor(indicesFlat.length / nLeaves) : 0;
+    const indices = [];
+    for (let i = 0; i < nLeaves; i++) {
+        const slice = indicesFlat.slice(i * leafSize, (i + 1) * leafSize);
+        while (slice.length < leafSize)
+            slice.push(-1);
+        indices.push(slice);
+    }
+    return {
+        hyperplanes,
+        offsets: offsetsArray,
+        children,
+        indices,
+    };
+}
+export function createSparseMatrixWasm(rows, cols, values, nRows, nCols) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    const rowsArray = new Int32Array(rows);
+    const colsArray = new Int32Array(cols);
+    const valuesArray = new Float64Array(values);
+    return new wasmModule.WasmSparseMatrix(rowsArray, colsArray, valuesArray, nRows, nCols);
+}
+export function sparseTransposeWasm(matrix) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_transpose(matrix);
+}
+export function sparseIdentityWasm(size) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_identity(size);
+}
+export function sparseAddWasm(a, b) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_add(a, b);
+}
+export function sparseSubtractWasm(a, b) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_subtract(a, b);
+}
+export function sparsePairwiseMultiplyWasm(a, b) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_pairwise_multiply(a, b);
+}
+export function sparseMaximumWasm(a, b) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_maximum(a, b);
+}
+export function sparseMultiplyScalarWasm(matrix, scalar) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_multiply_scalar(matrix, scalar);
+}
+export function sparseEliminateZerosWasm(matrix) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_eliminate_zeros(matrix);
+}
+export function sparseNormalizeWasm(matrix, normType = 'l2') {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_normalize(matrix, normType);
+}
+export function sparseGetCSRWasm(matrix) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    const result = Array.from(wasmModule.sparse_get_csr(matrix));
+    const nIndices = result[0];
+    const nValues = result[1];
+    const nIndptr = result[2];
+    const indices = result.slice(3, 3 + nIndices);
+    const values = result.slice(3 + nIndices, 3 + nIndices + nValues);
+    const indptr = result.slice(3 + nIndices + nValues, 3 + nIndices + nValues + nIndptr);
+    return { indices, values, indptr };
+}
+export function wasmSparseMatrixToArray(matrix) {
+    const flat = Array.from(matrix.to_array());
+    const nRows = matrix.n_rows;
+    const nCols = matrix.n_cols;
+    const result = [];
+    for (let i = 0; i < nRows; i++) {
+        result.push(flat.slice(i * nCols, (i + 1) * nCols));
+    }
+    return result;
+}
+export function wasmSparseMatrixGetAll(matrix) {
+    const flat = Array.from(matrix.get_all_ordered());
+    const entries = [];
+    for (let i = 0; i < flat.length; i += 3) {
+        entries.push({
+            row: flat[i],
+            col: flat[i + 1],
+            value: flat[i + 2],
+        });
+    }
+    return entries;
+}