@elarsaks/umap-wasm 0.5.1 → 0.9.1

package/README.md

@@ -1,9 +1,13 @@
-# 🚧 UNDER DEVELOPMENT 🚧
-
 # UMAP-WASM: WebAssembly-Accelerated UMAP for JavaScript
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 
+> **⚠️ Thesis Project Notice**: This library was developed as part of a master's thesis research project and is **not actively maintained**. While functional and tested, it is provided as-is for academic and experimental purposes. 
+
+![Performance Comparison](docs/runtime_by_machine.png)
+
+*Performance comparison across different machines. The baseline represents the pure JavaScript implementation (umap-js), while UMAP-WASM shows the WebAssembly-accelerated version. Note: The MacBook is approximately 5 years newer and more performant hardware compared to the Linux machine.*
+
 A high-performance implementation of Uniform Manifold Approximation and Projection (UMAP) for JavaScript environments, featuring selective WebAssembly acceleration for compute-intensive operations.
 
 ## 📦 Installation
@@ -16,17 +20,40 @@ yarn add umap-wasm
 
 ### Make the WASM artifacts available in the browser
 
-For browser builds the loader expects the compiled WASM bundle at `/wasm/pkg/web/umap_wasm_core.js` (and the accompanying `.wasm` binary) to be served as static assets. If your bundler does not automatically copy files from `node_modules`, add a `postinstall` script that copies only the web build into your public/static directory:
+For browser usage, WASM files must be served as static assets. The package includes pre-built WASM artifacts in `wasm/pkg/web/`. If your bundler doesn't automatically copy files from `node_modules`, add a postinstall script:
 
 ```json
 {
   "scripts": {
-    "postinstall": "mkdir -p public/wasm/pkg/web && cp -r node_modules/@elarsaks/umap-wasm/wasm/pkg/web/* public/wasm/pkg/web/"
+    "postinstall": "mkdir -p public/wasm && cp -r node_modules/@elarsaks/umap-wasm/wasm/pkg/web public/wasm/"
   }
 }
 ```
 
-Adjust the destination (`public/wasm/pkg`) to match your framework's static assets folder (e.g., `static/` for SvelteKit, `public/` for Vite/Next). Node.js-only usage does not need this step.
+Adjust the destination to match your framework:
+- Vite/React: `public/wasm/`
+- Next.js: `public/wasm/`
+- SvelteKit: `static/wasm/`
+
+The WASM loader will look for files at `/wasm/web/umap_wasm_core.js` and `/wasm/web/umap_wasm_core_bg.wasm`.
+
+Node.js environments don't require this step.
+
+## Reproducible WASM build (short note)
+
+If you need to rebuild the WASM artifacts locally, use the locked toolchain and skip post-build optimization to avoid runtime issues with externref tables. Recommended minimal steps:
+
+- Ensure the repository `rust-toolchain.toml` is respected (Rust 1.83.0).
+- Use `wasm-pack 0.13.1` and Node.js `22.22.0`.
+- Build with `--no-opt` to skip `wasm-opt` (example):
+
+```bash
+cd wasm
+RUSTFLAGS='-C target-feature=+simd128' wasm-pack build --no-opt --target web --out-dir pkg/web --release
+RUSTFLAGS='-C target-feature=+simd128' wasm-pack build --no-opt --target nodejs --out-dir pkg/node --release
+```
+
+Skipping `wasm-opt` avoids a post-processing pass that may break WebAssembly externref table handling; it yields larger but correct binaries. Only publish optimized binaries after ensuring they pass the full test-suite.
 
 ## 🚀 Usage
 
@@ -46,14 +73,13 @@ const embedding = umap.fit(data);
 
 ### WASM loading with progress
 
-If you want a progress bar while the WASM module downloads, pass a `wasmUrl`
-and `onProgress` callback:
+For progress tracking during WASM module loading:
 
 ```typescript
 import { initWasm } from 'umap-wasm';
 
 await initWasm({
-  wasmUrl: '/wasm/pkg/web/umap_wasm_core_bg.wasm',
+  wasmUrl: '/wasm/web/umap_wasm_core_bg.wasm',
   onProgress: ({ percent, phase }) => {
     console.log(`WASM ${phase}: ${percent ?? 0}%`);
   }
@@ -131,22 +157,33 @@ The UMAP constructor accepts a `UMAPParameters` object with the following option
 | `spread` | `number` | `1.0` | Effective scale of embedded points |
 | `random` | `() => number` | `Math.random` | PRNG for reproducibility |
 | `distanceFn` | `DistanceFn` | `euclidean` | Distance metric for input space |
-| `useWasmDistance` | `boolean` | `false` | Whether to use Rust/WASM distance functions when available |
-| `useWasmNNDescent` | `boolean` | `false` | Whether to use Rust/WASM NN-Descent implementation when available |
-| `useWasmTree` | `boolean` | `false` | Whether to use Rust/WASM random projection tree construction when available |
-| `useWasmMatrix` | `boolean` | `false` | Whether to use Rust/WASM sparse matrix operations when available |
-| `useWasmOptimizer` | `boolean` | `false` | Whether to use Rust/WASM gradient descent optimizer when available |
+| `useWasmDistance` | `boolean` | `false` | Use Rust/WASM distance functions (Euclidean, cosine, etc.) |
+| `useWasmNNDescent` | `boolean` | `false` | Use Rust/WASM NN-Descent for nearest neighbor graph refinement |
+| `useWasmTree` | `boolean` | `false` | Use Rust/WASM random projection trees for neighbor search |
+| `useWasmMatrix` | `boolean` | `false` | Use Rust/WASM sparse matrix operations |
+| `useWasmOptimizer` | `boolean` | `false` | Use Rust/WASM gradient descent optimizer |
 
+**WASM Performance Note**: Enable WASM features for improved performance on large datasets (1000+ points). For small datasets, JavaScript may be faster due to overhead.
 
-### Example with WASM Parameters
+### Example Configuration
 
 ```typescript
 import { UMAP } from 'umap-wasm';
 
+// Basic 2D embedding
 const umap = new UMAP({
-  nComponents: 3, // 3D embedding
+  nComponents: 2,
+  nNeighbors: 15,
+  minDist: 0.1
+});
+
+// 3D embedding with WASM acceleration
+const umapWasm = new UMAP({
+  nComponents: 3,
+  nNeighbors: 30,
   useWasmDistance: true,
-  useWasmNNDescent: true
+  useWasmNNDescent: true,
+  useWasmOptimizer: true
 });
 ```
 --- 
@@ -312,6 +349,8 @@ yarn test:ui
 yarn test:coverage
 ```
 
+**Note**: Some unit tests depend on the execution environment (CPU architecture, floating-point precision, random number generation). Test results may vary slightly across different machines and may fail in environments different from the development setup.
+
 ## 📊 Benchmarking
 
 Performance benchmarks are available in the companion `umap-bench` repository, which includes:
@@ -366,4 +405,4 @@ Tampere University of Applied Sciences
 
 ---
 
-*This README is maintained as part of academic research. Last updated: January 2026*
+*This README is maintained as part of academic research. Last updated: February 2026*

package/package.json

@@ -1,16 +1,31 @@
 {
   "name": "@elarsaks/umap-wasm",
-  "version": "0.5.1",
-  "description": "JavaScript implementation of UMAP",
+  "version": "0.9.1",
+  "description": "WebAssembly-Accelerated UMAP for JavaScript - High-performance dimension reduction for browser and Node.js",
+  "keywords": [
+    "umap",
+    "wasm",
+    "webassembly",
+    "dimension-reduction",
+    "machine-learning",
+    "visualization",
+    "manifold-learning",
+    "javascript",
+    "typescript",
+    "rust"
+  ],
   "author": {
     "name": "Elar Saks",
     "email": "elarsaks@gmail.com"
   },
-  "license": "MIT",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/elarsaks/umap-wasm.git"
   },
+  "bugs": {
+    "url": "https://github.com/elarsaks/umap-wasm/issues"
+  },
   "main": "lib/umap-js.js",
   "module": "dist/index.js",
   "unpkg": "lib/umap-js.min.js",
@@ -36,7 +51,7 @@
     "preview": "npx serve . -p 4173",
     "bundle": "rm -rf lib && webpack --config ./webpack/lib.config.mjs && webpack --config ./webpack/lib.min.config.mjs",
     "build": "rm -rf dist && tsc && yarn bundle",
-    "build:wasm": "cd wasm && RUSTFLAGS='-C target-feature=+simd128' wasm-pack build --target web --out-dir pkg/web --release && wasm-opt -O4 -o pkg/web/umap_wasm_core_bg.wasm pkg/web/umap_wasm_core_bg.wasm && RUSTFLAGS='-C target-feature=+simd128' wasm-pack build --target nodejs --out-dir pkg/node --release && wasm-opt -O4 -o pkg/node/umap_wasm_core_bg.wasm pkg/node/umap_wasm_core_bg.wasm && rm -f pkg/web/.gitignore pkg/node/.gitignore"
+    "build:wasm": "cd wasm && RUSTFLAGS='-C target-feature=+simd128' wasm-pack build --no-opt --target web --out-dir pkg/web --release && RUSTFLAGS='-C target-feature=+simd128' wasm-pack build --no-opt --target nodejs --out-dir pkg/node --release && rm -f pkg/web/.gitignore pkg/node/.gitignore"
   },
   "devDependencies": {
     "@playwright/test": "^1.57.0",

package/wasm/pkg/node/umap_wasm_core.d.ts

@@ -10,58 +10,58 @@ export class FlatTree {
    */
   hyperplanes(): Float64Array;
   /**
-   * Get the dimensionality
+   * Get the offsets as a Float64Array
    */
-  dim(): number;
+  offsets(): Float64Array;
   /**
-   * Get the leaf indices array
+   * Get the children array (pairs of child indices)
    */
-  indices(): Int32Array;
+  children(): Int32Array;
   /**
-   * Get number of nodes
+   * Get the leaf indices array
    */
-  n_nodes(): number;
+  indices(): Int32Array;
   /**
-   * Get the offsets as a Float64Array
+   * Get the dimensionality
    */
-  offsets(): Float64Array;
+  dim(): number;
   /**
-   * Get the children array (pairs of child indices)
+   * Get number of nodes
    */
-  children(): Int32Array;
+  n_nodes(): number;
 }
 
 export class OptimizerState {
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Seed the internal RNG used by the optimizer.
-   */
-  set_rng_seed(seed: bigint): void;
-  /**
-   * Get the length of the embedding buffer.
+   * Create a new optimizer state with the given parameters.
    */
-  head_embedding_len(): number;
+  constructor(head: Uint32Array, tail: Uint32Array, head_embedding: Float64Array, tail_embedding: Float64Array, epochs_per_sample: Float64Array, epochs_per_negative_sample: Float64Array, move_other: boolean, initial_alpha: number, gamma: number, a: number, b: number, dim: number, n_epochs: number, n_vertices: number);
   /**
    * Get a pointer to the embedding buffer (for zero-copy views).
    */
   head_embedding_ptr(): number;
   /**
-   * Create a new optimizer state with the given parameters.
+   * Get the length of the embedding buffer.
    */
-  constructor(head: Uint32Array, tail: Uint32Array, head_embedding: Float64Array, tail_embedding: Float64Array, epochs_per_sample: Float64Array, epochs_per_negative_sample: Float64Array, move_other: boolean, initial_alpha: number, gamma: number, a: number, b: number, dim: number, n_epochs: number, n_vertices: number);
+  head_embedding_len(): number;
   /**
-   * Get the current RNG seed/state.
+   * Seed the internal RNG used by the optimizer.
    */
-  rng_seed(): bigint;
+  set_rng_seed(seed: bigint): void;
   /**
-   * Get the current epoch number.
+   * Get the current RNG seed/state.
    */
-  readonly current_epoch: number;
+  rng_seed(): bigint;
   /**
    * Get the current embedding as a flat array.
    */
   readonly head_embedding: Float64Array;
+  /**
+   * Get the current epoch number.
+   */
+  readonly current_epoch: number;
   /**
    * Get the total number of epochs.
    */
@@ -71,22 +71,6 @@ export class OptimizerState {
 export class WasmSparseMatrix {
   free(): void;
   [Symbol.dispose](): void;
-  /**
-   * Get all values
-   */
-  get_values(): Float64Array;
-  /**
-   * Apply a scalar operation to all values (map with scalar)
-   */
-  map_scalar(operation: string, scalar: number): WasmSparseMatrix;
-  /**
-   * Get all entries as flat arrays [rows, cols, values] - ordered by row then col
-   */
-  get_all_ordered(): Float64Array;
-  /**
-   * Get a value at the given row and column, with a default value if not present
-   */
-  get(row: number, col: number, default_value: number): number;
   /**
    * Create a new sparse matrix from rows, cols, values, and dimensions.
    * 
@@ -98,18 +82,14 @@ export class WasmSparseMatrix {
    * * `n_cols` - Number of columns in the matrix
    */
   constructor(rows: Int32Array, cols: Int32Array, values: Float64Array, n_rows: number, n_cols: number);
-  /**
-   * Get number of non-zero entries
-   */
-  nnz(): number;
   /**
    * Set a value at the given row and column
    */
   set(row: number, col: number, value: number): void;
   /**
-   * Get all column indices
+   * Get a value at the given row and column, with a default value if not present
    */
-  get_cols(): Int32Array;
+  get(row: number, col: number, default_value: number): number;
   /**
    * Get the dimensions as [nRows, nCols]
    */
@@ -118,18 +98,38 @@ export class WasmSparseMatrix {
    * Get all row indices
    */
   get_rows(): Int32Array;
+  /**
+   * Get all column indices
+   */
+  get_cols(): Int32Array;
+  /**
+   * Get all values
+   */
+  get_values(): Float64Array;
+  /**
+   * Get all entries as flat arrays [rows, cols, values] - ordered by row then col
+   */
+  get_all_ordered(): Float64Array;
+  /**
+   * Get number of non-zero entries
+   */
+  nnz(): number;
   /**
    * Convert to dense 2D array (row-major, flattened)
    */
   to_array(): Float64Array;
   /**
-   * Get the number of columns
+   * Apply a scalar operation to all values (map with scalar)
    */
-  readonly n_cols: number;
+  map_scalar(operation: string, scalar: number): WasmSparseMatrix;
   /**
    * Get the number of rows
    */
   readonly n_rows: number;
+  /**
+   * Get the number of columns
+   */
+  readonly n_cols: number;
 }
 
 /**

package/wasm/pkg/node/umap_wasm_core.js

@@ -181,12 +181,22 @@ class FlatTree {
         return ret;
     }
     /**
-     * Get the dimensionality
-     * @returns {number}
+     * Get the offsets as a Float64Array
+     * @returns {Float64Array}
      */
-    dim() {
-        const ret = wasm.flattree_dim(this.__wbg_ptr);
-        return ret >>> 0;
+    offsets() {
+        const ret = wasm.flattree_offsets(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the children array (pairs of child indices)
+     * @returns {Int32Array}
+     */
+    children() {
+        const ret = wasm.flattree_children(this.__wbg_ptr);
+        var v1 = getArrayI32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
     }
     /**
      * Get the leaf indices array
@@ -199,30 +209,20 @@ class FlatTree {
         return v1;
     }
     /**
-     * Get number of nodes
+     * Get the dimensionality
      * @returns {number}
      */
-    n_nodes() {
-        const ret = wasm.flattree_n_nodes(this.__wbg_ptr);
+    dim() {
+        const ret = wasm.flattree_dim(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Get the offsets as a Float64Array
-     * @returns {Float64Array}
-     */
-    offsets() {
-        const ret = wasm.flattree_offsets(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Get the children array (pairs of child indices)
-     * @returns {Int32Array}
+     * Get number of nodes
+     * @returns {number}
      */
-    children() {
-        const ret = wasm.flattree_children(this.__wbg_ptr);
-        var v1 = getArrayI32FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    n_nodes() {
+        const ret = wasm.flattree_n_nodes(this.__wbg_ptr);
+        return ret >>> 0;
     }
 }
 if (Symbol.dispose) FlatTree.prototype[Symbol.dispose] = FlatTree.prototype.free;
@@ -243,47 +243,6 @@ class OptimizerState {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_optimizerstate_free(ptr, 0);
     }
-    /**
-     * Seed the internal RNG used by the optimizer.
-     * @param {bigint} seed
-     */
-    set_rng_seed(seed) {
-        wasm.optimizerstate_set_rng_seed(this.__wbg_ptr, seed);
-    }
-    /**
-     * Get the current epoch number.
-     * @returns {number}
-     */
-    get current_epoch() {
-        const ret = wasm.optimizerstate_current_epoch(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get the current embedding as a flat array.
-     * @returns {Float64Array}
-     */
-    get head_embedding() {
-        const ret = wasm.optimizerstate_head_embedding(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-    /**
-     * Get the length of the embedding buffer.
-     * @returns {number}
-     */
-    head_embedding_len() {
-        const ret = wasm.optimizerstate_head_embedding_len(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get a pointer to the embedding buffer (for zero-copy views).
-     * @returns {number}
-     */
-    head_embedding_ptr() {
-        const ret = wasm.optimizerstate_head_embedding_ptr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
     /**
      * Create a new optimizer state with the given parameters.
      * @param {Uint32Array} head
@@ -319,6 +278,40 @@ class OptimizerState {
         OptimizerStateFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Get the current embedding as a flat array.
+     * @returns {Float64Array}
+     */
+    get head_embedding() {
+        const ret = wasm.optimizerstate_head_embedding(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get a pointer to the embedding buffer (for zero-copy views).
+     * @returns {number}
+     */
+    head_embedding_ptr() {
+        const ret = wasm.optimizerstate_head_embedding_ptr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the length of the embedding buffer.
+     * @returns {number}
+     */
+    head_embedding_len() {
+        const ret = wasm.optimizerstate_head_embedding_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the current epoch number.
+     * @returns {number}
+     */
+    get current_epoch() {
+        const ret = wasm.optimizerstate_current_epoch(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Get the total number of epochs.
      * @returns {number}
@@ -327,6 +320,13 @@ class OptimizerState {
         const ret = wasm.optimizerstate_n_epochs(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Seed the internal RNG used by the optimizer.
+     * @param {bigint} seed
+     */
+    set_rng_seed(seed) {
+        wasm.optimizerstate_set_rng_seed(this.__wbg_ptr, seed);
+    }
     /**
      * Get the current RNG seed/state.
      * @returns {bigint}
@@ -363,53 +363,6 @@ class WasmSparseMatrix {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmsparsematrix_free(ptr, 0);
     }
-    /**
-     * Get all values
-     * @returns {Float64Array}
-     */
-    get_values() {
-        const ret = wasm.wasmsparsematrix_get_values(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Apply a scalar operation to all values (map with scalar)
-     * @param {string} operation
-     * @param {number} scalar
-     * @returns {WasmSparseMatrix}
-     */
-    map_scalar(operation, scalar) {
-        const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmsparsematrix_map_scalar(this.__wbg_ptr, ptr0, len0, scalar);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return WasmSparseMatrix.__wrap(ret[0]);
-    }
-    /**
-     * Get all entries as flat arrays [rows, cols, values] - ordered by row then col
-     * @returns {Float64Array}
-     */
-    get_all_ordered() {
-        const ret = wasm.wasmsparsematrix_get_all_ordered(this.__wbg_ptr);
-        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-        return v1;
-    }
-    /**
-     * Get a value at the given row and column, with a default value if not present
-     * @param {number} row
-     * @param {number} col
-     * @param {number} default_value
-     * @returns {number}
-     */
-    get(row, col, default_value) {
-        const ret = wasm.wasmsparsematrix_get(this.__wbg_ptr, row, col, default_value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
-    }
     /**
      * Create a new sparse matrix from rows, cols, values, and dimensions.
      *
@@ -441,11 +394,19 @@ class WasmSparseMatrix {
         return this;
     }
     /**
-     * Get number of non-zero entries
+     * Get the number of rows
      * @returns {number}
      */
-    nnz() {
-        const ret = wasm.wasmsparsematrix_nnz(this.__wbg_ptr);
+    get n_rows() {
+        const ret = wasm.wasmsparsematrix_n_rows(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the number of columns
+     * @returns {number}
+     */
+    get n_cols() {
+        const ret = wasm.wasmsparsematrix_n_cols(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -461,28 +422,18 @@ class WasmSparseMatrix {
         }
     }
     /**
-     * Get the number of columns
-     * @returns {number}
-     */
-    get n_cols() {
-        const ret = wasm.wasmsparsematrix_n_cols(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get the number of rows
+     * Get a value at the given row and column, with a default value if not present
+     * @param {number} row
+     * @param {number} col
+     * @param {number} default_value
      * @returns {number}
      */
-    get n_rows() {
-        const ret = wasm.wasmsparsematrix_n_rows(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get all column indices
-     * @returns {Int32Array}
-     */
-    get_cols() {
-        const ret = wasm.wasmsparsematrix_get_cols(this.__wbg_ptr);
-        return ret;
+    get(row, col, default_value) {
+        const ret = wasm.wasmsparsematrix_get(this.__wbg_ptr, row, col, default_value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
     }
     /**
      * Get the dimensions as [nRows, nCols]
@@ -502,6 +453,40 @@ class WasmSparseMatrix {
         const ret = wasm.wasmsparsematrix_get_rows(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Get all column indices
+     * @returns {Int32Array}
+     */
+    get_cols() {
+        const ret = wasm.wasmsparsematrix_get_cols(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get all values
+     * @returns {Float64Array}
+     */
+    get_values() {
+        const ret = wasm.wasmsparsematrix_get_values(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get all entries as flat arrays [rows, cols, values] - ordered by row then col
+     * @returns {Float64Array}
+     */
+    get_all_ordered() {
+        const ret = wasm.wasmsparsematrix_get_all_ordered(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Get number of non-zero entries
+     * @returns {number}
+     */
+    nnz() {
+        const ret = wasm.wasmsparsematrix_nnz(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Convert to dense 2D array (row-major, flattened)
      * @returns {Float64Array}
@@ -510,6 +495,21 @@ class WasmSparseMatrix {
         const ret = wasm.wasmsparsematrix_to_array(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Apply a scalar operation to all values (map with scalar)
+     * @param {string} operation
+     * @param {number} scalar
+     * @returns {WasmSparseMatrix}
+     */
+    map_scalar(operation, scalar) {
+        const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmsparsematrix_map_scalar(this.__wbg_ptr, ptr0, len0, scalar);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WasmSparseMatrix.__wrap(ret[0]);
+    }
 }
 if (Symbol.dispose) WasmSparseMatrix.prototype[Symbol.dispose] = WasmSparseMatrix.prototype.free;
 exports.WasmSparseMatrix = WasmSparseMatrix;