Return the datasets directory for a benchmark suite.

Symmetric eigendecomposition via Jacobi rotations. Input: `a` is an m×m symmetric matrix in row-major flat layout. Returns (eigenvalues sorted ascendi

Build an RP forest of n_trees trees.

Target embedding dimension. Default: 2.

The current live parameters.

Random embedding in [-10, 10]^dim.

Re-initialize the embedding and restart from epoch 0. Default: "spectral". Queued; runs in order after any in-flight `step`/`run`.

Run to a fixed horizon with linear learning-rate decay, mirroring standard run-to-completion UMAP. A fresh optimizer started at epoch 0 reproduces the

Update the live parameters (learning rate, repulsion, negative-sample rate, and the a/b curve parameters). Changing `negative_sample_rate` re-seeds t

Brute-force k-nearest neighbor computation for reference. Includes self-neighbor (distance 0) at position 0, consistent with pynndescent.

Run UMAP asynchronously (for WASM with GPU): build the graph + initial embedding, then optimize to completion. Output matches [`build`](Self::build).

Compute distances for the given pairs, filtering by thresholds. `pairs` is a flat slice of `[p0, q0, p1, q1, ...]` indices. `thresholds` has length `

Convert kNN distances to fuzzy set membership strengths.

Compute PageRank scores from a DataFrame that contains a neighbors column. The neighbors column contains one dict per row with two parallel

Convert the builder's post-order node list to a FlatTree with pre-order layout.

Create a class instance on the worker and return a typed proxy.

Fit the curve parameters (a, b) for the output distance function: f(x) = 1 / (1 + a * x^(2b)) The target curve is: y = 1.0 if x < min_di

Enable GPU acceleration via WebGPU. Default: false. Requires the `gpu` feature.

Creates a true or false dataflow depending on the value of the condition.

Convert the input to props of the EmbeddingAtlas view.

Create a new heap initialized with -1 indices, inf distances, and 0 flags.

Exact euclidean kNN in the umap-learn layout: row i lists point i itself in column 0 (distance 0), then its `k-1` nearest neighbors sorted ascending.

Async helper: map a buffer for reading and wait for it to be available. On native, `device.poll(Wait)` blocks until the map completes synchronously,

Distance metric name. Default: "euclidean".

Top-level NN-descent: initialize heap, run iterations, sort result. Returns (indices, distances) sorted by ascending distance.

Optimizer: "sgd" (default) or "momentum".

Set a progress callback: `(progress: number, stage: string) => void`. `progress` is in [0, 1], `stage` describes the current processing phase.

Build a command to run a benchmark Python module.

Extract all leaf arrays from a forest as a 2D array. Each row is a leaf's point indices, padded with -1.

Run a command, print it, return (success, duration).

Search a flat tree to find the leaf containing a query point. Returns (start, end) indices into tree.indices.

Compute sigma (bandwidth) and rho (local connectivity distance) for each point via binary search, matching the UMAP smooth_knn_dist algorithm.

Effective scale of embedded points. Default: 1.0.

Creates a value node.

Build the graph + initial embedding (eager) and return a stateful [`Umap`]. The embedding and kNN graph are valid immediately at epoch 0; call [`Umap

Build a Rust benchmark binary in release mode.

Return all cached entries as a dict of {name: value}.