@elarsaks/umap-wasm 0.1.0

package/dist/src/utils.d.ts

@@ -0,0 +1,16 @@
+import { RandomFn } from './umap';
+export declare function tauRandInt(n: number, random: RandomFn): number;
+export declare function tauRand(random: RandomFn): number;
+export declare function norm(vec: number[]): number;
+export declare function empty(n: number): undefined[];
+export declare function range(n: number): number[];
+export declare function filled(n: number, v: number): number[];
+export declare function zeros(n: number): number[];
+export declare function ones(n: number): number[];
+export declare function linear(a: number, b: number, len: number): number[];
+export declare function sum(input: number[]): number;
+export declare function mean(input: number[]): number;
+export declare function max(input: number[]): number;
+export declare function max2d(input: number[][]): number;
+export declare function rejectionSample(nSamples: number, poolSize: number, random: RandomFn): number[];
+export declare function reshape2d<T>(x: T[], a: number, b: number): T[][];

package/dist/src/utils.js

@@ -0,0 +1,137 @@
+"use strict";
+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.tauRandInt = tauRandInt;
+exports.tauRand = tauRand;
+exports.norm = norm;
+exports.empty = empty;
+exports.range = range;
+exports.filled = filled;
+exports.zeros = zeros;
+exports.ones = ones;
+exports.linear = linear;
+exports.sum = sum;
+exports.mean = mean;
+exports.max = max;
+exports.max2d = max2d;
+exports.rejectionSample = rejectionSample;
+exports.reshape2d = reshape2d;
+function tauRandInt(n, random) {
+    return Math.floor(random() * n);
+}
+function tauRand(random) {
+    return random();
+}
+function norm(vec) {
+    var e_1, _a;
+    var result = 0;
+    try {
+        for (var vec_1 = __values(vec), vec_1_1 = vec_1.next(); !vec_1_1.done; vec_1_1 = vec_1.next()) {
+            var item = vec_1_1.value;
+            result += Math.pow(item, 2);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (vec_1_1 && !vec_1_1.done && (_a = vec_1.return)) _a.call(vec_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return Math.sqrt(result);
+}
+function empty(n) {
+    var output = [];
+    for (var i = 0; i < n; i++) {
+        output.push(undefined);
+    }
+    return output;
+}
+function range(n) {
+    return empty(n).map(function (_, i) { return i; });
+}
+function filled(n, v) {
+    return empty(n).map(function () { return v; });
+}
+function zeros(n) {
+    return filled(n, 0);
+}
+function ones(n) {
+    return filled(n, 1);
+}
+function linear(a, b, len) {
+    return empty(len).map(function (_, i) {
+        return a + i * ((b - a) / (len - 1));
+    });
+}
+function sum(input) {
+    return input.reduce(function (sum, val) { return sum + val; });
+}
+function mean(input) {
+    return sum(input) / input.length;
+}
+function max(input) {
+    var max = 0;
+    for (var i = 0; i < input.length; i++) {
+        max = input[i] > max ? input[i] : max;
+    }
+    return max;
+}
+function max2d(input) {
+    var max = 0;
+    for (var i = 0; i < input.length; i++) {
+        for (var j = 0; j < input[i].length; j++) {
+            max = input[i][j] > max ? input[i][j] : max;
+        }
+    }
+    return max;
+}
+function rejectionSample(nSamples, poolSize, random) {
+    var result = zeros(nSamples);
+    for (var i = 0; i < nSamples; i++) {
+        var rejectSample = true;
+        while (rejectSample) {
+            var j = tauRandInt(poolSize, random);
+            var broken = false;
+            for (var k = 0; k < i; k++) {
+                if (j === result[k]) {
+                    broken = true;
+                    break;
+                }
+            }
+            if (!broken) {
+                rejectSample = false;
+            }
+            result[i] = j;
+        }
+    }
+    return result;
+}
+function reshape2d(x, a, b) {
+    var rows = [];
+    var count = 0;
+    var index = 0;
+    if (x.length !== a * b) {
+        throw new Error('Array dimensions must match input length.');
+    }
+    for (var i = 0; i < a; i++) {
+        var col = [];
+        for (var j = 0; j < b; j++) {
+            col.push(x[index]);
+            index += 1;
+        }
+        rows.push(col);
+        count += 1;
+    }
+    return rows;
+}

package/dist/src/wasmBridge.d.ts

@@ -0,0 +1,57 @@
+export declare function initWasm(): Promise<any>;
+export declare function isWasmAvailable(): boolean;
+export declare function euclideanWasm(x: number[], y: number[]): any;
+export declare function cosineWasm(x: number[], y: number[]): any;
+export interface WasmFlatTree {
+    hyperplanes(): Float64Array;
+    offsets(): Float64Array;
+    children(): Int32Array;
+    indices(): Int32Array;
+    dim(): number;
+    n_nodes(): number;
+    free(): void;
+}
+export declare function buildRpTreeWasm(data: number[][], nSamples: number, dim: number, leafSize: number, seed: number): WasmFlatTree;
+export declare function searchFlatTreeWasm(tree: WasmFlatTree, point: number[], seed: number): number[];
+export declare function wasmTreeToJs(wasmTree: WasmFlatTree): {
+    hyperplanes: number[][];
+    offsets: number[];
+    children: number[][];
+    indices: number[][];
+};
+export interface WasmSparseMatrix {
+    n_rows: number;
+    n_cols: number;
+    set(row: number, col: number, value: number): void;
+    get(row: number, col: number, defaultValue: number): number;
+    get_dims(): number[];
+    get_rows(): Int32Array;
+    get_cols(): Int32Array;
+    get_values(): Float64Array;
+    get_all_ordered(): Float64Array;
+    nnz(): number;
+    to_array(): Float64Array;
+    map_scalar(operation: string, scalar: number): WasmSparseMatrix;
+    free(): void;
+}
+export declare function createSparseMatrixWasm(rows: number[], cols: number[], values: number[], nRows: number, nCols: number): WasmSparseMatrix;
+export declare function sparseTransposeWasm(matrix: WasmSparseMatrix): WasmSparseMatrix;
+export declare function sparseIdentityWasm(size: number): WasmSparseMatrix;
+export declare function sparseAddWasm(a: WasmSparseMatrix, b: WasmSparseMatrix): WasmSparseMatrix;
+export declare function sparseSubtractWasm(a: WasmSparseMatrix, b: WasmSparseMatrix): WasmSparseMatrix;
+export declare function sparsePairwiseMultiplyWasm(a: WasmSparseMatrix, b: WasmSparseMatrix): WasmSparseMatrix;
+export declare function sparseMaximumWasm(a: WasmSparseMatrix, b: WasmSparseMatrix): WasmSparseMatrix;
+export declare function sparseMultiplyScalarWasm(matrix: WasmSparseMatrix, scalar: number): WasmSparseMatrix;
+export declare function sparseEliminateZerosWasm(matrix: WasmSparseMatrix): WasmSparseMatrix;
+export declare function sparseNormalizeWasm(matrix: WasmSparseMatrix, normType?: string): WasmSparseMatrix;
+export declare function sparseGetCSRWasm(matrix: WasmSparseMatrix): {
+    indices: number[];
+    values: number[];
+    indptr: number[];
+};
+export declare function wasmSparseMatrixToArray(matrix: WasmSparseMatrix): number[][];
+export declare function wasmSparseMatrixGetAll(matrix: WasmSparseMatrix): {
+    value: number;
+    row: number;
+    col: number;
+}[];

package/dist/src/wasmBridge.js

@@ -0,0 +1,290 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initWasm = initWasm;
+exports.isWasmAvailable = isWasmAvailable;
+exports.euclideanWasm = euclideanWasm;
+exports.cosineWasm = cosineWasm;
+exports.buildRpTreeWasm = buildRpTreeWasm;
+exports.searchFlatTreeWasm = searchFlatTreeWasm;
+exports.wasmTreeToJs = wasmTreeToJs;
+exports.createSparseMatrixWasm = createSparseMatrixWasm;
+exports.sparseTransposeWasm = sparseTransposeWasm;
+exports.sparseIdentityWasm = sparseIdentityWasm;
+exports.sparseAddWasm = sparseAddWasm;
+exports.sparseSubtractWasm = sparseSubtractWasm;
+exports.sparsePairwiseMultiplyWasm = sparsePairwiseMultiplyWasm;
+exports.sparseMaximumWasm = sparseMaximumWasm;
+exports.sparseMultiplyScalarWasm = sparseMultiplyScalarWasm;
+exports.sparseEliminateZerosWasm = sparseEliminateZerosWasm;
+exports.sparseNormalizeWasm = sparseNormalizeWasm;
+exports.sparseGetCSRWasm = sparseGetCSRWasm;
+exports.wasmSparseMatrixToArray = wasmSparseMatrixToArray;
+exports.wasmSparseMatrixGetAll = wasmSparseMatrixGetAll;
+var wasmReady = null;
+var wasmModule = null;
+function initWasm() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+            if (wasmReady)
+                return [2, wasmReady];
+            wasmReady = (function () { return __awaiter(_this, void 0, void 0, function () {
+                var isNode, wasmPath, mod, err_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 3]);
+                            isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+                            wasmPath = isNode
+                                ? '../wasm/pkg/node/umap_wasm_core.js'
+                                : '../wasm/pkg/web/umap_wasm_core.js';
+                            return [4, Promise.resolve("".concat(wasmPath)).then(function (s) { return __importStar(require(s)); })];
+                        case 1:
+                            mod = _a.sent();
+                            wasmModule = mod;
+                            return [2, mod];
+                        case 2:
+                            err_1 = _a.sent();
+                            wasmReady = null;
+                            wasmModule = null;
+                            throw new Error("Failed to load WASM module: ".concat(err_1));
+                        case 3: return [2];
+                    }
+                });
+            }); })();
+            return [2, wasmReady];
+        });
+    });
+}
+function isWasmAvailable() {
+    return wasmModule !== null;
+}
+function euclideanWasm(x, y) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    var xa = new Float64Array(x);
+    var ya = new Float64Array(y);
+    return wasmModule.euclidean(xa, ya);
+}
+function cosineWasm(x, y) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    var xa = new Float64Array(x);
+    var ya = new Float64Array(y);
+    return wasmModule.cosine(xa, ya);
+}
+function buildRpTreeWasm(data, nSamples, dim, leafSize, seed) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    var flatData = new Float64Array(nSamples * dim);
+    for (var i = 0; i < nSamples; i++) {
+        for (var j = 0; j < dim; j++) {
+            flatData[i * dim + j] = data[i][j];
+        }
+    }
+    return wasmModule.build_rp_tree(flatData, nSamples, dim, leafSize, BigInt(seed));
+}
+function searchFlatTreeWasm(tree, point, seed) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    var pointArray = new Float64Array(point);
+    var result = wasmModule.search_flat_tree(tree, pointArray, BigInt(seed));
+    return Array.from(result);
+}
+function wasmTreeToJs(wasmTree) {
+    var hyperplanesFlat = Array.from(wasmTree.hyperplanes());
+    var offsetsArray = Array.from(wasmTree.offsets());
+    var childrenFlat = Array.from(wasmTree.children());
+    var indicesFlat = Array.from(wasmTree.indices());
+    var dim = wasmTree.dim();
+    var nNodes = wasmTree.n_nodes();
+    var hyperplanes = [];
+    for (var i = 0; i < nNodes; i++) {
+        hyperplanes.push(hyperplanesFlat.slice(i * dim, (i + 1) * dim));
+    }
+    var children = [];
+    for (var i = 0; i < nNodes; i++) {
+        children.push([childrenFlat[i * 2], childrenFlat[i * 2 + 1]]);
+    }
+    var maxLeafIdx = 0;
+    for (var i = 0; i < childrenFlat.length; i++) {
+        var v = childrenFlat[i];
+        if (v <= 0) {
+            var leafIdx = -v;
+            if (leafIdx > maxLeafIdx)
+                maxLeafIdx = leafIdx;
+        }
+    }
+    var nLeaves = maxLeafIdx + 1;
+    var leafSize = nLeaves > 0 ? Math.floor(indicesFlat.length / nLeaves) : 0;
+    var indices = [];
+    for (var i = 0; i < nLeaves; i++) {
+        var slice = indicesFlat.slice(i * leafSize, (i + 1) * leafSize);
+        while (slice.length < leafSize)
+            slice.push(-1);
+        indices.push(slice);
+    }
+    return {
+        hyperplanes: hyperplanes,
+        offsets: offsetsArray,
+        children: children,
+        indices: indices,
+    };
+}
+function createSparseMatrixWasm(rows, cols, values, nRows, nCols) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    var rowsArray = new Int32Array(rows);
+    var colsArray = new Int32Array(cols);
+    var valuesArray = new Float64Array(values);
+    return new wasmModule.WasmSparseMatrix(rowsArray, colsArray, valuesArray, nRows, nCols);
+}
+function sparseTransposeWasm(matrix) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_transpose(matrix);
+}
+function sparseIdentityWasm(size) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_identity(size);
+}
+function sparseAddWasm(a, b) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_add(a, b);
+}
+function sparseSubtractWasm(a, b) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_subtract(a, b);
+}
+function sparsePairwiseMultiplyWasm(a, b) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_pairwise_multiply(a, b);
+}
+function sparseMaximumWasm(a, b) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_maximum(a, b);
+}
+function sparseMultiplyScalarWasm(matrix, scalar) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_multiply_scalar(matrix, scalar);
+}
+function sparseEliminateZerosWasm(matrix) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_eliminate_zeros(matrix);
+}
+function sparseNormalizeWasm(matrix, normType) {
+    if (normType === void 0) { normType = 'l2'; }
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    return wasmModule.sparse_normalize(matrix, normType);
+}
+function sparseGetCSRWasm(matrix) {
+    if (!wasmModule)
+        throw new Error('WASM module not initialized');
+    var result = Array.from(wasmModule.sparse_get_csr(matrix));
+    var nIndices = result[0];
+    var nValues = result[1];
+    var nIndptr = result[2];
+    var indices = result.slice(3, 3 + nIndices);
+    var values = result.slice(3 + nIndices, 3 + nIndices + nValues);
+    var indptr = result.slice(3 + nIndices + nValues, 3 + nIndices + nValues + nIndptr);
+    return { indices: indices, values: values, indptr: indptr };
+}
+function wasmSparseMatrixToArray(matrix) {
+    var flat = Array.from(matrix.to_array());
+    var nRows = matrix.n_rows;
+    var nCols = matrix.n_cols;
+    var result = [];
+    for (var i = 0; i < nRows; i++) {
+        result.push(flat.slice(i * nCols, (i + 1) * nCols));
+    }
+    return result;
+}
+function wasmSparseMatrixGetAll(matrix) {
+    var flat = Array.from(matrix.get_all_ordered());
+    var entries = [];
+    for (var i = 0; i < flat.length; i += 3) {
+        entries.push({
+            row: flat[i],
+            col: flat[i + 1],
+            value: flat[i + 2],
+        });
+    }
+    return entries;
+}

package/dist/test/matrix.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/matrix.test.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var matrix_1 = require("../src/matrix");
+describe('sparse matrix', function () {
+    test('constructs a sparse matrix from rows/cols/vals ', function () {
+        var rows = [0, 0, 1, 1];
+        var cols = [0, 1, 0, 1];
+        var vals = [1, 2, 3, 4];
+        var dims = [2, 2];
+        var matrix = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+        expect(matrix.getRows()).toEqual(rows);
+        expect(matrix.getCols()).toEqual(cols);
+        expect(matrix.getValues()).toEqual(vals);
+        expect(matrix.nRows).toEqual(2);
+        expect(matrix.nCols).toEqual(2);
+    });
+    test('sparse matrix has get / set methods', function () {
+        var rows = [0, 0, 1, 1];
+        var cols = [0, 1, 0, 1];
+        var vals = [1, 2, 3, 4];
+        var dims = [2, 2];
+        var matrix = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+        expect(matrix.get(0, 1)).toEqual(2);
+        matrix.set(0, 1, 9);
+        expect(matrix.get(0, 1)).toEqual(9);
+    });
+    test('sparse matrix has getAll method', function () {
+        var rows = [0, 0, 1, 1];
+        var cols = [0, 1, 0, 1];
+        var vals = [1, 2, 3, 4];
+        var dims = [2, 2];
+        var matrix = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+        expect(matrix.getAll()).toEqual([
+            { row: 0, col: 0, value: 1 },
+            { row: 0, col: 1, value: 2 },
+            { row: 1, col: 0, value: 3 },
+            { row: 1, col: 1, value: 4 },
+        ]);
+    });
+    test('sparse matrix has toArray method', function () {
+        var rows = [0, 0, 1, 1];
+        var cols = [0, 1, 0, 1];
+        var vals = [1, 2, 3, 4];
+        var dims = [2, 2];
+        var matrix = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+        expect(matrix.toArray()).toEqual([[1, 2], [3, 4]]);
+    });
+    test('sparse matrix has map method', function () {
+        var rows = [0, 0, 1, 1];
+        var cols = [0, 1, 0, 1];
+        var vals = [1, 2, 3, 4];
+        var dims = [2, 2];
+        var matrix = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+        var newMatrix = matrix.map(function (value) {
+            return value + 1;
+        });
+        expect(newMatrix.toArray()).toEqual([[2, 3], [4, 5]]);
+    });
+    test('sparse matrix has forEach', function () {
+        var rows = [0, 1];
+        var cols = [0, 0];
+        var vals = [1, 3];
+        var dims = [2, 2];
+        var matrix = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+        var entries = [];
+        matrix.forEach(function (value, row, col) {
+            entries.push([value, row, col]);
+        });
+        expect(entries).toEqual([[1, 0, 0], [3, 1, 0]]);
+    });
+});
+describe('helper methods', function () {
+    var A;
+    var B;
+    beforeEach(function () {
+        var rows = [0, 0, 1, 1];
+        var cols = [0, 1, 0, 1];
+        var vals = [1, 2, 3, 4];
+        var dims = [2, 2];
+        A = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+        B = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+    });
+    test('transpose method', function () {
+        var T = (0, matrix_1.transpose)(A);
+        expect(T.toArray()).toEqual([[1, 3], [2, 4]]);
+    });
+    test('identity method', function () {
+        var I = (0, matrix_1.identity)([2, 2]);
+        expect(I.toArray()).toEqual([[1, 0], [0, 1]]);
+    });
+    test('pairwise multiply method', function () {
+        var X = (0, matrix_1.pairwiseMultiply)(A, B);
+        expect(X.toArray()).toEqual([[1, 4], [9, 16]]);
+    });
+    test('add method', function () {
+        var X = (0, matrix_1.add)(A, B);
+        expect(X.toArray()).toEqual([[2, 4], [6, 8]]);
+    });
+    test('subtract method', function () {
+        var X = (0, matrix_1.subtract)(A, B);
+        expect(X.toArray()).toEqual([[0, 0], [0, 0]]);
+    });
+    test('element-wise maximum method', function () {
+        var I = (0, matrix_1.multiplyScalar)((0, matrix_1.identity)([2, 2]), 8);
+        var X = (0, matrix_1.maximum)(A, I);
+        expect(X.toArray()).toEqual([[8, 2], [3, 8]]);
+    });
+    test('scalar multiply method', function () {
+        var X = (0, matrix_1.multiplyScalar)(A, 3);
+        expect(X.toArray()).toEqual([[3, 6], [9, 12]]);
+    });
+    test('eliminateZeros method', function () {
+        var defaultValue = 11;
+        var rows = [0, 1, 1];
+        var cols = [0, 0, 1];
+        var vals = [0, 1, 3];
+        var dims = [2, 2];
+        var matrix = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+        expect(matrix.get(0, 0, defaultValue)).toEqual(0);
+        var eliminated = (0, matrix_1.eliminateZeros)(matrix);
+        expect(eliminated.getValues()).toEqual([1, 3]);
+        expect(eliminated.getRows()).toEqual([1, 1]);
+        expect(eliminated.getCols()).toEqual([0, 1]);
+        expect(eliminated.get(0, 0, defaultValue)).toEqual(defaultValue);
+    });
+});
+describe('normalize method', function () {
+    var A;
+    beforeEach(function () {
+        var rows = [0, 0, 0, 1, 1, 1, 2, 2, 2];
+        var cols = [0, 1, 2, 0, 1, 2, 0, 1, 2];
+        var vals = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        var dims = [3, 3];
+        A = new matrix_1.SparseMatrix(rows, cols, vals, dims);
+    });
+    test('max normalization method', function () {
+        var expected = [
+            [0.3333333333333333, 0.6666666666666666, 1.0],
+            [0.6666666666666666, 0.8333333333333334, 1.0],
+            [0.7777777777777778, 0.8888888888888888, 1.0],
+        ];
+        var n = (0, matrix_1.normalize)(A, "max");
+        expect(n.toArray()).toEqual(expected);
+    });
+    test('l1 normalization method', function () {
+        var expected = [
+            [0.16666666666666666, 0.3333333333333333, 0.5],
+            [0.26666666666666666, 0.3333333333333333, 0.4],
+            [0.2916666666666667, 0.3333333333333333, 0.375],
+        ];
+        var n = (0, matrix_1.normalize)(A, "l1");
+        expect(n.toArray()).toEqual(expected);
+    });
+    test('l2 normalization method (default)', function () {
+        var expected = [
+            [0.2672612419124244, 0.5345224838248488, 0.8017837257372732],
+            [0.4558423058385518, 0.5698028822981898, 0.6837634587578277],
+            [0.5025707110324167, 0.5743665268941904, 0.6461623427559643],
+        ];
+        var n = (0, matrix_1.normalize)(A);
+        expect(n.toArray()).toEqual(expected);
+    });
+    test('getCSR function', function () {
+        var _a = (0, matrix_1.getCSR)(A), indices = _a.indices, values = _a.values, indptr = _a.indptr;
+        expect(indices).toEqual([0, 1, 2, 0, 1, 2, 0, 1, 2]);
+        expect(values).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        expect(indptr).toEqual([0, 3, 6]);
+    });
+});

package/dist/test/nn_descent.test.d.ts

@@ -0,0 +1 @@
+export {};