@woosh/meep-engine 2.138.20 → 2.140.0

package/src/core/graph/metis/native/coarsen/match_shem.js

@@ -0,0 +1,175 @@
+import { array_quick_sort_by_lookup_uint } from "../../../../collection/array/array_quick_sort_by_lookup_uint.js";
+import { array_shuffle } from "../../../../collection/array/array_shuffle.js";
+
+const UNMATCHED = 0xFFFFFFFF;
+
+/**
+ * Sorted Heavy-Edge Matching.
+ *
+ * Visits vertices in random order biased toward lower degree first, and for
+ * each unmatched vertex pairs it with the unmatched neighbour sharing the
+ * heaviest edge weight (subject to a coarse-vertex weight cap).
+ *
+ * Outputs:
+ *  - `graph.coarse_vertex_map[v]` = id of the coarse vertex that vertex v
+ *    collapses into. Numbered so that iterating v=0..vertex_count walks coarse
+ *    ids 0..coarse_vertex_count-1 in order — this property is required by
+ *    `create_coarse_graph`.
+ *  - `partner_of_vertex[v]` = the partner of vertex v (or v itself if it ended
+ *    up alone in the matching). Caller-provided buffer, filled in place.
+ *  - returns `coarse_vertex_count`, the number of coarse vertices created.
+ *
+ * Mirrors `Match_SHEM` from libmetis/coarsen.c, single-constraint branch.
+ * The 2-hop matching escape hatch is intentionally skipped — it's a degeneracy
+ * recovery for graphs with many isolated/low-degree vertices that's not on the
+ * critical path; can add later if cluster quality bites.
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph
+ * @param {function():number} random seeded RNG
+ * @param {number} max_coarse_vertex_weight cap on the combined weight of a
+ *   matched pair; vertices whose own weight already exceeds this are forced
+ *   into singleton coarse vertices
+ * @param {Uint32Array} partner_of_vertex caller-provided buffer of length
+ *   `>= graph.vertex_count`. Will be filled with each vertex's match partner
+ *   (or its own id if it ended up unmatched). The first `graph.vertex_count`
+ *   entries are clobbered; any tail beyond that is left untouched.
+ * @param {Uint32Array} visit_order caller-provided scratch of length
+ *   `>= graph.vertex_count`. Used as the (random-shuffled, degree-sorted)
+ *   visitation order during matching. Contents on entry are ignored;
+ *   contents on return are undefined.
+ * @param {Uint32Array} sort_key_degree caller-provided scratch of length
+ *   `>= graph.vertex_count`. Holds the per-vertex degree buckets used to sort
+ *   `visit_order`. Contents on entry are ignored; contents on return are undefined.
+ * @returns {number} `coarse_vertex_count`
+ */
+export function match_shem(
+    graph,
+    random,
+    max_coarse_vertex_weight,
+    partner_of_vertex,
+    visit_order,
+    sort_key_degree
+) {
+
+    const vertex_count = graph.vertex_count;
+    const edge_addresses = graph.edge_addresses;
+    const adjacency = graph.adjacency;
+    const edge_weights = graph.edge_weights;
+    const vertex_weights = graph.vertex_weights;
+
+    const coarse_vertex_map = graph.coarse_vertex_map !== null && graph.coarse_vertex_map.length === vertex_count
+        ? graph.coarse_vertex_map
+        : new Uint32Array(vertex_count);
+    graph.coarse_vertex_map = coarse_vertex_map;
+
+    partner_of_vertex.fill(UNMATCHED, 0, vertex_count);
+
+    if (vertex_count === 0) {
+        return 0;
+    }
+
+    // Visitation order: random permutation, then sorted ascending by capped
+    // degree so low-degree (harder to match) vertices get first pick.
+    for (let v = 0; v < vertex_count; v++) {
+        visit_order[v] = v;
+    }
+    array_shuffle(random, visit_order, vertex_count);
+
+    // Visitation order key: bucket vertices by sqrt(1 + degree), capped at
+    // 4× average degree. Mirrors master's heuristic — much more permissive
+    // than 5.1.0's raw-degree + 0.7× cap. Effect: visitation order is roughly
+    // logarithmic in degree, so isolated high-degree outliers don't dominate
+    // the ordering. For graphs with degree variance (real meshes have these),
+    // this gives more uniform matching coverage.
+    const total_adjacency_length = edge_addresses[vertex_count];
+    const average_degree = Math.max(1, Math.floor(4.0 * (total_adjacency_length / vertex_count)));
+
+    for (let v = 0; v < vertex_count; v++) {
+        const degree = edge_addresses[v + 1] - edge_addresses[v];
+        const bucket = Math.floor(Math.sqrt(1 + degree));
+        sort_key_degree[v] = bucket > average_degree ? average_degree : bucket;
+    }
+
+    if (vertex_count > 1) {
+        array_quick_sort_by_lookup_uint(visit_order, sort_key_degree, 0, vertex_count - 1);
+    }
+
+    // --- Pass 1: matching --------------------------------------------------
+    let next_unmatched_search_start = 0;
+
+    for (let visit_position = 0; visit_position < vertex_count; visit_position++) {
+        const vertex = visit_order[visit_position];
+
+        if (partner_of_vertex[vertex] !== UNMATCHED) {
+            continue;
+        }
+
+        let best_partner = vertex;       // self-match if no candidate is found
+        let best_partner_edge_weight = -1;
+
+        if (vertex_weights[vertex] < max_coarse_vertex_weight) {
+
+            const edge_start = edge_addresses[vertex];
+            const edge_end = edge_addresses[vertex + 1];
+
+            if (edge_start === edge_end) {
+                // Isolated vertex: forward-scan visit_order for any other unmatched
+                // vertex. Mirrors METIS's "island" path, which ignores the weight cap
+                // for these pairings.
+                if (next_unmatched_search_start < visit_position) {
+                    next_unmatched_search_start = visit_position;
+                }
+                next_unmatched_search_start++;
+                while (next_unmatched_search_start < vertex_count) {
+                    const candidate = visit_order[next_unmatched_search_start];
+                    if (partner_of_vertex[candidate] === UNMATCHED) {
+                        best_partner = candidate;
+                        break;
+                    }
+                    next_unmatched_search_start++;
+                }
+            } else {
+                // Heavy-edge: pick the unmatched neighbour whose edge has the
+                // greatest weight, subject to the coarse-weight cap.
+                for (let edge_offset = edge_start; edge_offset < edge_end; edge_offset++) {
+                    const neighbor = adjacency[edge_offset];
+                    const weight = edge_weights[edge_offset];
+                    if (
+                        partner_of_vertex[neighbor] === UNMATCHED &&
+                        weight > best_partner_edge_weight &&
+                        vertex_weights[vertex] + vertex_weights[neighbor] <= max_coarse_vertex_weight
+                    ) {
+                        best_partner = neighbor;
+                        best_partner_edge_weight = weight;
+                    }
+                }
+            }
+        }
+
+        if (best_partner !== vertex) {
+            partner_of_vertex[vertex] = best_partner;
+            partner_of_vertex[best_partner] = vertex;
+        }
+        // else: leave UNMATCHED; the renumbering pass below will self-match it.
+    }
+
+    // --- Pass 2: renumber coarse_vertex_map in vertex-id order -------------
+    // `create_coarse_graph` requires that when it processes vertices in order
+    // v = 0..vertex_count, coarse_vertex_map[v] equals the running count of
+    // coarse vertices produced so far. Also self-match anything still UNMATCHED.
+    let coarse_vertex_count = 0;
+    for (let vertex = 0; vertex < vertex_count; vertex++) {
+        const partner = partner_of_vertex[vertex];
+        if (partner === UNMATCHED) {
+            partner_of_vertex[vertex] = vertex;
+            coarse_vertex_map[vertex] = coarse_vertex_count;
+            coarse_vertex_count++;
+        } else if (vertex <= partner) {
+            coarse_vertex_map[vertex] = coarse_vertex_count;
+            coarse_vertex_map[partner] = coarse_vertex_count;
+            coarse_vertex_count++;
+        }
+    }
+
+    return coarse_vertex_count;
+}

package/src/core/graph/metis/native/initial/initial_kway_bfs.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Initial k-way partition via simultaneous BFS from k random seed vertices.
+ *
+ * Each seed grows its partition outward by FIFO BFS, claiming any neighbour
+ * that hasn't been claimed yet. A partition stops growing once its accumulated
+ * vertex weight crosses the per-partition target. Any vertices left unassigned
+ * — typically because their component was fully consumed by a partition that
+ * then hit its cap, or because the graph has more than k components — get
+ * assigned to whichever partition is currently lightest.
+ *
+ * This is a quality-vs-simplicity trade-off relative to METIS's recursive
+ * bisection on the coarsest graph. Bisection produces lower edge cuts but
+ * costs roughly 5× the code. FM uncoarsening recovers a large fraction of the
+ * quality difference, so we ship BFS-growth first and revisit if needed.
+ *
+ * Writes to `graph.vertex_partition[]` and `graph.partition_weights[]`. Both
+ * must already be allocated (call `graph.allocate_partition_state(partition_count)`).
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph the coarsest graph
+ * @param {number} partition_count
+ * @param {function():number} random
+ */
+export function initial_kway_bfs(graph: import('../MetisGraph.js').MetisGraph, partition_count: number, random: () => number): void;
+//# sourceMappingURL=initial_kway_bfs.d.ts.map

package/src/core/graph/metis/native/initial/initial_kway_bfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial_kway_bfs.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/initial/initial_kway_bfs.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wCAJW,OAAO,kBAAkB,EAAE,UAAU,mBACrC,MAAM,gBACK,MAAM,QAyF3B"}

package/src/core/graph/metis/native/initial/initial_kway_bfs.js

@@ -0,0 +1,122 @@
+import { array_shuffle } from "../../../../collection/array/array_shuffle.js";
+
+const UNASSIGNED = 0xFFFFFFFF;
+
+/**
+ * Fractional overshoot allowed for a partition's weight during BFS growth.
+ * Once a partition crosses `target_weight × this`, it stops claiming new
+ * neighbours. A small slack avoids starving a partition that hits the target
+ * exactly mid-step.
+ */
+const GROWTH_OVERSHOOT_FRACTION = 1.05;
+
+/**
+ * Initial k-way partition via simultaneous BFS from k random seed vertices.
+ *
+ * Each seed grows its partition outward by FIFO BFS, claiming any neighbour
+ * that hasn't been claimed yet. A partition stops growing once its accumulated
+ * vertex weight crosses the per-partition target. Any vertices left unassigned
+ * — typically because their component was fully consumed by a partition that
+ * then hit its cap, or because the graph has more than k components — get
+ * assigned to whichever partition is currently lightest.
+ *
+ * This is a quality-vs-simplicity trade-off relative to METIS's recursive
+ * bisection on the coarsest graph. Bisection produces lower edge cuts but
+ * costs roughly 5× the code. FM uncoarsening recovers a large fraction of the
+ * quality difference, so we ship BFS-growth first and revisit if needed.
+ *
+ * Writes to `graph.vertex_partition[]` and `graph.partition_weights[]`. Both
+ * must already be allocated (call `graph.allocate_partition_state(partition_count)`).
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph the coarsest graph
+ * @param {number} partition_count
+ * @param {function():number} random
+ */
+export function initial_kway_bfs(graph, partition_count, random) {
+    const vertex_count = graph.vertex_count;
+    const edge_addresses = graph.edge_addresses;
+    const adjacency = graph.adjacency;
+    const vertex_weights = graph.vertex_weights;
+    const total_vertex_weight = graph.total_vertex_weight;
+    const vertex_partition = graph.vertex_partition;
+    const partition_weights = graph.partition_weights;
+
+    vertex_partition.fill(UNASSIGNED);
+    partition_weights.fill(0);
+
+    if (vertex_count === 0 || partition_count === 0) {
+        return;
+    }
+
+    const partition_weight_cap = Math.ceil((total_vertex_weight / partition_count) * GROWTH_OVERSHOOT_FRACTION);
+
+    // Pick k distinct seeds by shuffling all vertex ids and taking the prefix.
+    // Cheaper alternatives exist for k << vertex_count but this is simple and
+    // unambiguously correct.
+    const shuffled_vertex_ids = new Uint32Array(vertex_count);
+    for (let v = 0; v < vertex_count; v++) {
+        shuffled_vertex_ids[v] = v;
+    }
+    array_shuffle(random, shuffled_vertex_ids);
+
+    // Shared (vertex, partition) FIFO queue. We claim a vertex by writing to
+    // vertex_partition at push time, so every vertex is pushed at most once
+    // and 2*vertex_count bounds the queue size.
+    const bfs_queue = new Uint32Array(vertex_count * 2);
+    let queue_head = 0;
+    let queue_tail = 0;
+
+    const seed_count = Math.min(partition_count, vertex_count);
+    for (let partition = 0; partition < seed_count; partition++) {
+        const seed_vertex = shuffled_vertex_ids[partition];
+        vertex_partition[seed_vertex] = partition;
+        partition_weights[partition] = vertex_weights[seed_vertex];
+        bfs_queue[queue_tail++] = seed_vertex;
+        bfs_queue[queue_tail++] = partition;
+    }
+
+    while (queue_head < queue_tail) {
+        const vertex = bfs_queue[queue_head++];
+        const partition = bfs_queue[queue_head++];
+
+        if (partition_weights[partition] >= partition_weight_cap) {
+            continue;
+        }
+
+        const edge_start = edge_addresses[vertex];
+        const edge_end = edge_addresses[vertex + 1];
+        for (let edge_offset = edge_start; edge_offset < edge_end; edge_offset++) {
+            const neighbor = adjacency[edge_offset];
+            if (vertex_partition[neighbor] !== UNASSIGNED) {
+                continue;
+            }
+            vertex_partition[neighbor] = partition;
+            partition_weights[partition] += vertex_weights[neighbor];
+            bfs_queue[queue_tail++] = neighbor;
+            bfs_queue[queue_tail++] = partition;
+            if (partition_weights[partition] >= partition_weight_cap) {
+                break;
+            }
+        }
+    }
+
+    // Mop up vertices left unassigned (disconnected components, or stranded
+    // because every neighbour was claimed before the BFS reached them and the
+    // claiming partition then hit its cap). Assign each to the currently
+    // lightest partition.
+    for (let vertex = 0; vertex < vertex_count; vertex++) {
+        if (vertex_partition[vertex] !== UNASSIGNED) {
+            continue;
+        }
+        let lightest_partition = 0;
+        let lightest_partition_weight = partition_weights[0];
+        for (let partition = 1; partition < partition_count; partition++) {
+            if (partition_weights[partition] < lightest_partition_weight) {
+                lightest_partition_weight = partition_weights[partition];
+                lightest_partition = partition;
+            }
+        }
+        vertex_partition[vertex] = lightest_partition;
+        partition_weights[lightest_partition] += vertex_weights[vertex];
+    }
+}

package/src/core/graph/metis/native/initial/initial_kway_recursive_bisection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Initial k-way partitioning via multilevel recursive bisection (MLRB) — the
+ * approach described in Karypis & Kumar 1998, §2.2.
+ *
+ * Quality-wise this is the algorithm the paper actually advocates for the
+ * initial-partition phase. We split the graph in two with weights proportional
+ * to the k-way target, recurse on each half, then project the resulting
+ * sub-partitions back as a 0..k-1 assignment on the parent.
+ *
+ * Compared to `initial_kway_bfs`, MLRB produces meaningfully better initial
+ * cuts at the cost of more work at this phase. Since refinement dominates total
+ * runtime, the overall slowdown is small while the cut improvement is large.
+ *
+ * Mirrors `MlevelRecursiveBisection` from libmetis/pmetis.c, sans the inner
+ * coarsening loop — at this point our caller has already coarsened the graph
+ * and we operate on the coarsest level only.
+ *
+ * Writes to `graph.vertex_partition[]` (sized for `partition_count` partitions,
+ * values in [0, partition_count)). On entry `graph.vertex_partition` may be
+ * unallocated; we install fresh state.
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph the coarsest graph from
+ *   the outer multilevel pipeline
+ * @param {number} partition_count k
+ * @param {number} ub_factor load-imbalance factor (typically 1.03)
+ * @param {function():number} random
+ */
+export function initial_kway_recursive_bisection(graph: import('../MetisGraph.js').MetisGraph, partition_count: number, ub_factor: number, random: () => number): void;
+//# sourceMappingURL=initial_kway_recursive_bisection.d.ts.map

package/src/core/graph/metis/native/initial/initial_kway_recursive_bisection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial_kway_recursive_bisection.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/initial/initial_kway_recursive_bisection.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wDANW,OAAO,kBAAkB,EAAE,UAAU,mBAErC,MAAM,aACN,MAAM,gBACK,MAAM,QAgB3B"}

package/src/core/graph/metis/native/initial/initial_kway_recursive_bisection.js

@@ -0,0 +1,170 @@
+import { BisectionScratch } from "../bisection/BisectionScratch.js";
+import { bisect_graph } from "../bisection/bisect_graph.js";
+import { split_graph_two_way } from "../bisection/split_graph_two_way.js";
+
+/**
+ * How many independent bisection trials to run per recursive level.
+ * METIS uses 4-5; we settle on 4 as a reasonable speed/quality tradeoff.
+ */
+const BISECTION_TRIALS_PER_LEVEL = 4;
+
+/**
+ * FM passes per bisection trial. METIS uses 10.
+ */
+const FM_PASSES_PER_TRIAL = 10;
+
+/**
+ * Initial k-way partitioning via multilevel recursive bisection (MLRB) — the
+ * approach described in Karypis & Kumar 1998, §2.2.
+ *
+ * Quality-wise this is the algorithm the paper actually advocates for the
+ * initial-partition phase. We split the graph in two with weights proportional
+ * to the k-way target, recurse on each half, then project the resulting
+ * sub-partitions back as a 0..k-1 assignment on the parent.
+ *
+ * Compared to `initial_kway_bfs`, MLRB produces meaningfully better initial
+ * cuts at the cost of more work at this phase. Since refinement dominates total
+ * runtime, the overall slowdown is small while the cut improvement is large.
+ *
+ * Mirrors `MlevelRecursiveBisection` from libmetis/pmetis.c, sans the inner
+ * coarsening loop — at this point our caller has already coarsened the graph
+ * and we operate on the coarsest level only.
+ *
+ * Writes to `graph.vertex_partition[]` (sized for `partition_count` partitions,
+ * values in [0, partition_count)). On entry `graph.vertex_partition` may be
+ * unallocated; we install fresh state.
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph the coarsest graph from
+ *   the outer multilevel pipeline
+ * @param {number} partition_count k
+ * @param {number} ub_factor load-imbalance factor (typically 1.03)
+ * @param {function():number} random
+ */
+export function initial_kway_recursive_bisection(graph, partition_count, ub_factor, random) {
+    if (partition_count === 1) {
+        if (graph.vertex_partition === null) {
+            graph.vertex_partition = new Uint32Array(graph.vertex_count);
+        }
+        graph.vertex_partition.fill(0);
+        return;
+    }
+
+    // Single scratch allocation reused by every recursive bisect_graph call.
+    // Sized to the coarsest graph; subgraphs only ever touch [0, sub_vertex_count).
+    const scratch = new BisectionScratch(graph.vertex_count);
+
+    recursive_bisect_into_range(graph, 0, partition_count, ub_factor, random, scratch);
+}
+
+/**
+ * Recursively bisect `graph` so that on return `graph.vertex_partition[v]`
+ * holds an integer in `[first_partition_id, first_partition_id + partition_count)`.
+ *
+ * Each call takes one vertex_partition slot from the scratch pool, uses it as
+ * the graph's partition assignment, and releases it on return. Pool depth is
+ * bounded by recursion depth (= log2(k)), so at most ~log2(k) slots are ever
+ * live simultaneously — one per stack frame.
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph
+ * @param {number} first_partition_id offset into the parent's partition id space
+ * @param {number} partition_count how many partitions to split this graph into
+ * @param {number} ub_factor
+ * @param {function():number} random
+ * @param {import('../bisection/BisectionScratch.js').BisectionScratch} scratch
+ */
+function recursive_bisect_into_range(graph, first_partition_id, partition_count, ub_factor, random, scratch) {
+    if (partition_count === 1) {
+        // Leaf: assign every vertex of this subgraph to `first_partition_id`.
+        // Borrow a slot from the pool — same as non-leaf calls so the projection
+        // step in the parent can read it back uniformly.
+        const vertex_partition = scratch.take_vertex_partition_slot(graph.vertex_count);
+        if (first_partition_id !== 0) {
+            vertex_partition.fill(first_partition_id, 0, graph.vertex_count);
+        }
+        graph.vertex_partition = vertex_partition;
+        return;
+    }
+
+    // Split k into left_count + right_count such that left_count weights the
+    // bisection target proportionally. For an odd k we put the extra partition
+    // on the right; this is arbitrary but matches METIS's convention.
+    const left_partition_count = Math.floor(partition_count / 2);
+    const right_partition_count = partition_count - left_partition_count;
+
+    // Bisection target: partition 0 gets `left_partition_count / partition_count`
+    // of the total vertex weight, so that subsequent recursion produces evenly
+    // weighted leaves overall.
+    const target_weight_for_partition_0 = Math.round(
+        graph.total_vertex_weight * left_partition_count / partition_count
+    );
+
+    const vertex_partition = scratch.take_vertex_partition_slot(graph.vertex_count);
+
+    bisect_graph(
+        graph,
+        vertex_partition,
+        target_weight_for_partition_0,
+        BISECTION_TRIALS_PER_LEVEL,
+        FM_PASSES_PER_TRIAL,
+        ub_factor,
+        random,
+        scratch
+    );
+
+    if (partition_count === 2) {
+        // Base case: the bisection result IS the final k=2 assignment,
+        // just shifted into the right id range.
+        if (first_partition_id !== 0) {
+            const n = graph.vertex_count;
+            for (let v = 0; v < n; v++) {
+                vertex_partition[v] += first_partition_id;
+            }
+        }
+        // Don't release the slot here — the caller's projection step needs to
+        // read graph.vertex_partition. The parent's recursive_bisect_into_range
+        // releases it after projecting.
+        return;
+    }
+
+    // General case: split the graph into two subgraphs, recurse on each, then
+    // project the sub-partitions back into `graph.vertex_partition`.
+    const {
+        side_0_subgraph,
+        side_1_subgraph,
+        side_0_subgraph_to_parent,
+        side_1_subgraph_to_parent
+    } = split_graph_two_way(graph);
+
+    recursive_bisect_into_range(
+        side_0_subgraph,
+        first_partition_id,
+        left_partition_count,
+        ub_factor,
+        random,
+        scratch
+    );
+    recursive_bisect_into_range(
+        side_1_subgraph,
+        first_partition_id + left_partition_count,
+        right_partition_count,
+        ub_factor,
+        random,
+        scratch
+    );
+
+    // Project assignments back into our own slot.
+    const side_0_partition = side_0_subgraph.vertex_partition;
+    const side_1_partition = side_1_subgraph.vertex_partition;
+
+    for (let sub_v = 0; sub_v < side_0_subgraph.vertex_count; sub_v++) {
+        vertex_partition[side_0_subgraph_to_parent[sub_v]] = side_0_partition[sub_v];
+    }
+    for (let sub_v = 0; sub_v < side_1_subgraph.vertex_count; sub_v++) {
+        vertex_partition[side_1_subgraph_to_parent[sub_v]] = side_1_partition[sub_v];
+    }
+
+    // Children's vertex_partition slots are now free — release them in LIFO
+    // order (side_1 was taken last, so it pops first).
+    scratch.release_vertex_partition_slot();  // side_1
+    scratch.release_vertex_partition_slot();  // side_0
+}

package/src/core/graph/metis/native/metis_partition_kway.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure-JS k-way graph partitioning, drop-in compatible with the existing
+ * `micron_partition(...)` WASM-backed entry point.
+ *
+ * Implements the multilevel pipeline: coarsen → initial partition → uncoarsen
+ * with refinement at every level. Scope matches the subset that meep's
+ * `metis_cluster_bs` actually uses:
+ *   - cut-objective only
+ *   - single balance constraint, all vertex weights = 1
+ *   - uniform target partition weights
+ *   - no minconn / contig / volume / multi-constraint paths
+ *
+ * @param {number} vertex_count
+ * @param {number} partition_count
+ * @param {Uint32Array} edge_addresses CSR row pointers, length vertex_count + 1
+ * @param {Uint32Array} adjacency CSR column indices, length edge_addresses[vertex_count]
+ * @param {Uint32Array} edge_weights parallel to adjacency
+ * @param {{
+ *   seed?: number,
+ *   niter?: number,
+ *   ufactor?: number,
+ *   initial_partition_strategy?: 'recursive_bisection' | 'bfs',
+ * }} [options]
+ *   Only a small slice of `metis_options` is wired; everything else uses METIS
+ *   defaults.
+ *   - `ufactor`: load imbalance factor in METIS units (per-mille over 1.0;
+ *     ufactor = 30 → ub_factor = 1.03). Default 30.
+ *   - `niter`: number of FM passes per level. Default 10.
+ *   - `seed`: RNG seed; same seed + same input ⇒ same partition. Default 0.
+ *   - `initial_partition_strategy`: 'recursive_bisection' (Karypis-Kumar §2.2,
+ *     higher quality) or 'bfs' (simpler, faster initial phase, weaker cut).
+ *     Default 'recursive_bisection'.
+ * @returns {Uint32Array} partition assignment per vertex, values in [0, partition_count)
+ */
+export function metis_partition_kway(vertex_count: number, partition_count: number, edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Uint32Array, options?: {
+    seed?: number;
+    niter?: number;
+    ufactor?: number;
+    initial_partition_strategy?: 'recursive_bisection' | 'bfs';
+}): Uint32Array;
+//# sourceMappingURL=metis_partition_kway.d.ts.map

package/src/core/graph/metis/native/metis_partition_kway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metis_partition_kway.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/metis/native/metis_partition_kway.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,mDAtBW,MAAM,mBACN,MAAM,kBACN,WAAW,aACX,WAAW,gBACX,WAAW;WAEV,MAAM;YACL,MAAM;cACJ,MAAM;iCACa,qBAAqB,GAAG,KAAK;IAWlD,WAAW,CAoFvB"}