@woosh/meep-engine 2.138.20 → 2.139.0

package/src/core/graph/metis/native/refine/IndexedFloatMaxHeap.js

@@ -0,0 +1,261 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ * Max-heap of (uint32 id, float32 score) entries with an external id→slot index
+ * for O(log n) `update` and `remove` by id (rather than O(n) linear scan).
+ *
+ * Used by the k-way Fiduccia–Mattheyses refinement, where each vertex move
+ * requires updating the gain entries of every neighbour's boundary vertex.
+ * Without the index, that's O(degree · |boundary|) per move; with it,
+ * O(degree · log |boundary|).
+ *
+ * Behaviour notes:
+ *  - This is a MAX-heap (`pop_max` returns the entry with the largest score).
+ *  - Ids must be in `[0, id_capacity)`; the index table is sized at construction.
+ *  - Duplicate ids are not allowed. Calling `insert` with an existing id throws.
+ *
+ * Storage layout mirrors meep's `Uint32Heap`: each heap slot is 8 bytes packed
+ * as `(float32 score, uint32 id)`. The id→slot map is a separate
+ * `Uint32Array(id_capacity)` where `SLOT_NOT_PRESENT` means "not in heap".
+ *
+ * We measured a JS `Map<number, number>` as the index instead — it removes the
+ * eager `id_capacity` allocation but added 35-60% to FM-dominated benchmarks
+ * because `Map.get/set/delete` per `__swap_slots` call (O(log n) per pop) is
+ * meaningfully slower than typed-array indexing. Kept the typed-array form.
+ */
+
+const SLOT_NOT_PRESENT = 0xFFFFFFFF;
+const BYTES_PER_SLOT = 8;
+
+export class IndexedFloatMaxHeap {
+    /**
+     * @param {number} id_capacity ids must be in [0, id_capacity)
+     * @param {number} [initial_slot_capacity] initial heap slot count (grows on demand)
+     */
+    constructor(
+        id_capacity,
+        initial_slot_capacity = Math.min(64, id_capacity)
+    ) {
+        assert.isNonNegativeInteger(id_capacity, 'id_capacity');
+        assert.isNonNegativeInteger(initial_slot_capacity, 'initial_slot_capacity');
+
+        this.__slot_capacity = initial_slot_capacity;
+        this.__size = 0;
+
+        this.__data_buffer = new ArrayBuffer(initial_slot_capacity * BYTES_PER_SLOT);
+        this.__data_uint32 = new Uint32Array(this.__data_buffer);
+        this.__data_float32 = new Float32Array(this.__data_buffer);
+
+        /**
+         * Maps id → slot index in [0, size), or SLOT_NOT_PRESENT.
+         * @type {Uint32Array}
+         */
+        this.__slot_of_id = new Uint32Array(id_capacity);
+        this.__slot_of_id.fill(SLOT_NOT_PRESENT);
+    }
+
+    get size() {
+        return this.__size;
+    }
+
+    /**
+     * Empty the heap. Only resets the index entries that are actually populated,
+     * so this is O(size), not O(id_capacity).
+     */
+    clear() {
+        const data_uint32 = this.__data_uint32;
+        const size = this.__size;
+        const slot_of_id = this.__slot_of_id;
+        for (let slot = 0; slot < size; slot++) {
+            slot_of_id[data_uint32[slot * 2 + 1]] = SLOT_NOT_PRESENT;
+        }
+        this.__size = 0;
+    }
+
+    contains(id) {
+        return this.__slot_of_id[id] !== SLOT_NOT_PRESENT;
+    }
+
+    /**
+     * Swap the entries at two slot indices, keeping the id→slot index in sync.
+     * @private
+     */
+    __swap_slots(slot_a, slot_b) {
+        const data_uint32 = this.__data_uint32;
+        const word_a = slot_a << 1;
+        const word_b = slot_b << 1;
+
+        const score_a = data_uint32[word_a];
+        const id_a    = data_uint32[word_a + 1];
+        const score_b = data_uint32[word_b];
+        const id_b    = data_uint32[word_b + 1];
+
+        data_uint32[word_a]     = score_b;
+        data_uint32[word_a + 1] = id_b;
+        data_uint32[word_b]     = score_a;
+        data_uint32[word_b + 1] = id_a;
+
+        const slot_of_id = this.__slot_of_id;
+        slot_of_id[id_a] = slot_b;
+        slot_of_id[id_b] = slot_a;
+    }
+
+    /**
+     * Restore heap order downward starting at `start_slot`. Used when an entry's
+     * score has just decreased.
+     * @private
+     */
+    __sift_down(start_slot) {
+        const size = this.__size;
+        const data_float32 = this.__data_float32;
+        let slot = start_slot;
+
+        for (;;) {
+            const left_child = (slot << 1) + 1;
+            const right_child = left_child + 1;
+            let largest_slot = slot;
+
+            if (left_child < size && data_float32[left_child * 2] > data_float32[largest_slot * 2]) {
+                largest_slot = left_child;
+            }
+            if (right_child < size && data_float32[right_child * 2] > data_float32[largest_slot * 2]) {
+                largest_slot = right_child;
+            }
+            if (largest_slot === slot) {
+                break;
+            }
+            this.__swap_slots(slot, largest_slot);
+            slot = largest_slot;
+        }
+    }
+
+    /**
+     * Restore heap order upward starting at `start_slot`. Used when an entry's
+     * score has just increased.
+     * @private
+     */
+    __sift_up(start_slot) {
+        const data_float32 = this.__data_float32;
+        let slot = start_slot;
+
+        while (slot > 0) {
+            const parent_slot = (slot - 1) >> 1;
+            if (data_float32[parent_slot * 2] >= data_float32[slot * 2]) {
+                break;
+            }
+            this.__swap_slots(parent_slot, slot);
+            slot = parent_slot;
+        }
+    }
+
+    __grow_capacity() {
+        const old_capacity = this.__slot_capacity;
+        const new_capacity = Math.max(old_capacity + 16, Math.ceil(old_capacity * 1.5));
+        const new_buffer = new ArrayBuffer(new_capacity * BYTES_PER_SLOT);
+        const new_uint32 = new Uint32Array(new_buffer);
+        new_uint32.set(this.__data_uint32);
+        this.__data_buffer = new_buffer;
+        this.__data_uint32 = new_uint32;
+        this.__data_float32 = new Float32Array(new_buffer);
+        this.__slot_capacity = new_capacity;
+    }
+
+    /**
+     * @param {number} id
+     * @param {number} score
+     */
+    insert(id, score) {
+        if (this.__slot_of_id[id] !== SLOT_NOT_PRESENT) {
+            throw new Error(`id ${id} already in heap`);
+        }
+        if (this.__size >= this.__slot_capacity) {
+            this.__grow_capacity();
+        }
+        const new_slot = this.__size;
+        this.__data_float32[new_slot * 2] = score;
+        this.__data_uint32[new_slot * 2 + 1] = id;
+        this.__slot_of_id[id] = new_slot;
+        this.__size = new_slot + 1;
+        this.__sift_up(new_slot);
+    }
+
+    /**
+     * @returns {number} id of the entry with the largest score, or -1 if empty
+     */
+    pop_max() {
+        if (this.__size === 0) {
+            return -1;
+        }
+        const data_uint32 = this.__data_uint32;
+        const top_id = data_uint32[1];
+        const new_size = this.__size - 1;
+        this.__size = new_size;
+        this.__slot_of_id[top_id] = SLOT_NOT_PRESENT;
+
+        if (new_size > 0) {
+            const last_slot_word = new_size << 1;
+            const moved_score = this.__data_float32[last_slot_word];
+            const moved_id = data_uint32[last_slot_word + 1];
+            this.__data_float32[0] = moved_score;
+            data_uint32[1] = moved_id;
+            this.__slot_of_id[moved_id] = 0;
+            this.__sift_down(0);
+        }
+
+        return top_id;
+    }
+
+    /**
+     * @param {number} id
+     * @param {number} new_score
+     */
+    update(id, new_score) {
+        const slot = this.__slot_of_id[id];
+        if (slot === SLOT_NOT_PRESENT) {
+            throw new Error(`id ${id} not in heap`);
+        }
+        const slot_score_address = slot * 2;
+        const old_score = this.__data_float32[slot_score_address];
+        this.__data_float32[slot_score_address] = new_score;
+        if (new_score > old_score) {
+            this.__sift_up(slot);
+        } else if (new_score < old_score) {
+            this.__sift_down(slot);
+        }
+    }
+
+    /**
+     * @param {number} id
+     * @returns {boolean} true if the id was present and removed
+     */
+    remove(id) {
+        const slot = this.__slot_of_id[id];
+        if (slot === SLOT_NOT_PRESENT) {
+            return false;
+        }
+        this.__slot_of_id[id] = SLOT_NOT_PRESENT;
+        const new_size = this.__size - 1;
+        this.__size = new_size;
+
+        if (slot === new_size) {
+            return true;
+        }
+
+        // Move the last entry into the vacated slot, then restore heap order.
+        const last_slot_word = new_size << 1;
+        const moved_score = this.__data_float32[last_slot_word];
+        const moved_id = this.__data_uint32[last_slot_word + 1];
+        const slot_word = slot * 2;
+        const old_slot_score = this.__data_float32[slot_word];
+        this.__data_float32[slot_word] = moved_score;
+        this.__data_uint32[slot_word + 1] = moved_id;
+        this.__slot_of_id[moved_id] = slot;
+
+        if (moved_score > old_slot_score) {
+            this.__sift_up(slot);
+        } else {
+            this.__sift_down(slot);
+        }
+        return true;
+    }
+}

package/src/core/graph/metis/native/refine/RefinementScratch.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pre-allocated scratch reused across every `fm_kway` call during the
+ * uncoarsening / refinement phase.
+ *
+ * `refine_kway` invokes `fm_kway` once per multilevel level (typically 3-15
+ * times per partition run). Each call previously allocated:
+ *   - one `IndexedFloatMaxHeap` (with a `Uint32Array(vertex_count)` index table —
+ *     4 MB at 1M vertices)
+ *   - three vertex-sized typed arrays for queue status and touched bookkeeping
+ *   - two partition-count-sized arrays for the weight bounds
+ *
+ * Sharing one set of arrays scoped to the original (finest) graph's vertex
+ * count means the heap's index table is sized once and the rest of the state
+ * is reused across all levels.
+ *
+ * The arrays' invariants are preserved across calls without explicit clears:
+ *
+ *   - `queue_status` starts all-0 (NOT_PRESENT). Each fm_kway pass resets
+ *     touched entries back to 0 in its cleanup, so subsequent calls see a
+ *     clean slate without needing a fresh `.fill(0)`.
+ *
+ *   - `touched_position_of_vertex` starts all -1. Same per-pass cleanup
+ *     restores -1 for every touched entry.
+ *
+ *   - The heap uses `.clear()` at the start of each pass — that's O(size),
+ *     not O(capacity), and resets `__slot_of_id` only for the entries actually
+ *     in the heap.
+ */
+export class RefinementScratch {
+    /**
+     * @param {number} max_vertex_count typically the original (finest) graph's vertex count
+     * @param {number} partition_count
+     */
+    constructor(max_vertex_count: number, partition_count: number);
+    max_vertex_count: number;
+    partition_count: number;
+    move_queue: IndexedFloatMaxHeap;
+    queue_status: Uint8Array;
+    touched_vertices: Uint32Array;
+    touched_position_of_vertex: Int32Array;
+    partition_weight_min: Uint32Array;
+    partition_weight_max: Uint32Array;
+}
+import { IndexedFloatMaxHeap } from "./IndexedFloatMaxHeap.js";
+//# sourceMappingURL=RefinementScratch.d.ts.map

package/src/core/graph/metis/native/refine/RefinementScratch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefinementScratch.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/RefinementScratch.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IACI;;;OAGG;IACH,8BAHW,MAAM,mBACN,MAAM,EAkBhB;IAfG,yBAAwC;IACxC,wBAAsC;IAEtC,gCAGC;IAED,yBAAoD;IACpD,8BAAyD;IACzD,uCAAkE;IAGlE,kCAA4D;IAC5D,kCAA4D;CAEnE;oCApDmC,0BAA0B"}

package/src/core/graph/metis/native/refine/RefinementScratch.js

@@ -0,0 +1,53 @@
+import { IndexedFloatMaxHeap } from "./IndexedFloatMaxHeap.js";
+
+/**
+ * Pre-allocated scratch reused across every `fm_kway` call during the
+ * uncoarsening / refinement phase.
+ *
+ * `refine_kway` invokes `fm_kway` once per multilevel level (typically 3-15
+ * times per partition run). Each call previously allocated:
+ *   - one `IndexedFloatMaxHeap` (with a `Uint32Array(vertex_count)` index table —
+ *     4 MB at 1M vertices)
+ *   - three vertex-sized typed arrays for queue status and touched bookkeeping
+ *   - two partition-count-sized arrays for the weight bounds
+ *
+ * Sharing one set of arrays scoped to the original (finest) graph's vertex
+ * count means the heap's index table is sized once and the rest of the state
+ * is reused across all levels.
+ *
+ * The arrays' invariants are preserved across calls without explicit clears:
+ *
+ *   - `queue_status` starts all-0 (NOT_PRESENT). Each fm_kway pass resets
+ *     touched entries back to 0 in its cleanup, so subsequent calls see a
+ *     clean slate without needing a fresh `.fill(0)`.
+ *
+ *   - `touched_position_of_vertex` starts all -1. Same per-pass cleanup
+ *     restores -1 for every touched entry.
+ *
+ *   - The heap uses `.clear()` at the start of each pass — that's O(size),
+ *     not O(capacity), and resets `__slot_of_id` only for the entries actually
+ *     in the heap.
+ */
+export class RefinementScratch {
+    /**
+     * @param {number} max_vertex_count typically the original (finest) graph's vertex count
+     * @param {number} partition_count
+     */
+    constructor(max_vertex_count, partition_count) {
+        this.max_vertex_count = max_vertex_count;
+        this.partition_count = partition_count;
+
+        this.move_queue = new IndexedFloatMaxHeap(
+            max_vertex_count,
+            Math.min(max_vertex_count, 1024)
+        );
+
+        this.queue_status = new Uint8Array(max_vertex_count);
+        this.touched_vertices = new Uint32Array(max_vertex_count);
+        this.touched_position_of_vertex = new Int32Array(max_vertex_count);
+        this.touched_position_of_vertex.fill(-1);
+
+        this.partition_weight_min = new Uint32Array(partition_count);
+        this.partition_weight_max = new Uint32Array(partition_count);
+    }
+}

package/src/core/graph/metis/native/refine/compute_kway_params.d.ts

@@ -0,0 +1,18 @@
+/**
+ * From a freshly-assigned `vertex_partition[]`, populate the rest of the k-way
+ * refinement state: per-partition weights, per-vertex internal/external degree,
+ * the neighbour-partition list (via `neighbor_partition_pool`), the boundary
+ * list, and the total edge cut.
+ *
+ * Mirrors `ComputeKWayPartitionParams` from libmetis/kwayrefine.c, cut-objective
+ * branch only.
+ *
+ * Boundary insertion rule (refinement-type boundary): a vertex is added to the
+ * boundary when `external_degree >= internal_degree`. That captures "worth
+ * considering for a move" — vertices with no external pull aren't candidates.
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph
+ * @param {number} partition_count
+ */
+export function compute_kway_params(graph: import('../MetisGraph.js').MetisGraph, partition_count: number): void;
+//# sourceMappingURL=compute_kway_params.d.ts.map

package/src/core/graph/metis/native/refine/compute_kway_params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_kway_params.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/compute_kway_params.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,2CAHW,OAAO,kBAAkB,EAAE,UAAU,mBACrC,MAAM,QAyHhB"}

package/src/core/graph/metis/native/refine/compute_kway_params.js

@@ -0,0 +1,138 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ * From a freshly-assigned `vertex_partition[]`, populate the rest of the k-way
+ * refinement state: per-partition weights, per-vertex internal/external degree,
+ * the neighbour-partition list (via `neighbor_partition_pool`), the boundary
+ * list, and the total edge cut.
+ *
+ * Mirrors `ComputeKWayPartitionParams` from libmetis/kwayrefine.c, cut-objective
+ * branch only.
+ *
+ * Boundary insertion rule (refinement-type boundary): a vertex is added to the
+ * boundary when `external_degree >= internal_degree`. That captures "worth
+ * considering for a move" — vertices with no external pull aren't candidates.
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph
+ * @param {number} partition_count
+ */
+export function compute_kway_params(graph, partition_count) {
+    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 vertex_partition = graph.vertex_partition;
+    const partition_weights = graph.partition_weights;
+    const internal_degree = graph.internal_degree;
+    const external_degree = graph.external_degree;
+    const neighbor_partition_count = graph.neighbor_partition_count;
+    const neighbor_partition_offset = graph.neighbor_partition_offset;
+    const boundary_vertices = graph.boundary_vertices;
+    const boundary_position_of_vertex = graph.boundary_position_of_vertex;
+    const neighbor_partition_pool = graph.neighbor_partition_pool;
+
+    assert.equal(vertex_partition !== null, true, 'graph.vertex_partition must be allocated');
+    assert.equal(neighbor_partition_pool !== null, true, 'graph.neighbor_partition_pool must be allocated');
+
+    partition_weights.fill(0);
+    internal_degree.fill(0);
+    external_degree.fill(0);
+    neighbor_partition_count.fill(0);
+    neighbor_partition_offset.fill(-1);
+    boundary_position_of_vertex.fill(-1);
+    neighbor_partition_pool.clear();
+
+    // Recompute partition weights from `vertex_partition`. initial_kway_bfs
+    // already produces these, but refinement passes invalidate the count, so
+    // recompute unconditionally to keep this routine self-contained.
+    for (let v = 0; v < vertex_count; v++) {
+        partition_weights[vertex_partition[v]] += vertex_weights[v];
+    }
+
+    // Scratch arrays for per-vertex neighbour-partition deduplication:
+    //   `scratch_partition_position[p]` = where in `scratch_partition_id` /
+    //   `scratch_partition_edge_weight` we've stored partition p for the current
+    //   vertex, or -1 if p hasn't been seen yet for this vertex.
+    const scratch_partition_position = new Int32Array(partition_count);
+    scratch_partition_position.fill(-1);
+
+    // A vertex's distinct neighbour-partition count never exceeds its degree
+    // nor `partition_count`; `partition_count` is the safe upper bound on
+    // scratch size.
+    const scratch_partition_id = new Uint32Array(partition_count);
+    const scratch_partition_edge_weight = new Uint32Array(partition_count);
+
+    let boundary_count = 0;
+    let cut_doubled = 0;
+
+    const pool_data = neighbor_partition_pool.data_uint32;
+
+    for (let vertex = 0; vertex < vertex_count; vertex++) {
+        const my_partition = vertex_partition[vertex];
+
+        let v_internal_degree = 0;
+        let v_external_degree = 0;
+        let distinct_neighbor_partitions = 0;
+
+        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_partition = vertex_partition[adjacency[edge_offset]];
+            const edge_weight = edge_weights[edge_offset];
+            if (neighbor_partition === my_partition) {
+                v_internal_degree += edge_weight;
+            } else {
+                v_external_degree += edge_weight;
+                const existing_position = scratch_partition_position[neighbor_partition];
+                if (existing_position === -1) {
+                    scratch_partition_position[neighbor_partition] = distinct_neighbor_partitions;
+                    scratch_partition_id[distinct_neighbor_partitions] = neighbor_partition;
+                    scratch_partition_edge_weight[distinct_neighbor_partitions] = edge_weight;
+                    distinct_neighbor_partitions++;
+                } else {
+                    scratch_partition_edge_weight[existing_position] += edge_weight;
+                }
+            }
+        }
+
+        internal_degree[vertex] = v_internal_degree;
+        external_degree[vertex] = v_external_degree;
+
+        if (v_external_degree > 0) {
+            cut_doubled += v_external_degree;
+
+            // Reserve pool slots sized to the vertex's degree (not just the
+            // current distinct-neighbour-partition count). fm_kway can grow
+            // a vertex's neighbour-partition list when its neighbours move
+            // and introduce a new partition; we need room.
+            const degree = edge_end - edge_start;
+            const pool_record_offset = neighbor_partition_pool.allocate_continuous(degree);
+            neighbor_partition_offset[vertex] = pool_record_offset;
+            neighbor_partition_count[vertex] = distinct_neighbor_partitions;
+
+            // Each pool record is 8 bytes = 2 uint32 words: (partition_id, edge_weight).
+            const word_base = neighbor_partition_pool.element_word(pool_record_offset);
+            for (let nbr = 0; nbr < distinct_neighbor_partitions; nbr++) {
+                pool_data[word_base + nbr * 2] = scratch_partition_id[nbr];
+                pool_data[word_base + nbr * 2 + 1] = scratch_partition_edge_weight[nbr];
+            }
+
+            if (v_external_degree >= v_internal_degree) {
+                boundary_vertices[boundary_count] = vertex;
+                boundary_position_of_vertex[vertex] = boundary_count;
+                boundary_count++;
+            }
+        }
+
+        // Reset only the touched scratch entries.
+        for (let nbr = 0; nbr < distinct_neighbor_partitions; nbr++) {
+            scratch_partition_position[scratch_partition_id[nbr]] = -1;
+        }
+    }
+
+    // Each crossing edge contributes to both endpoints' external_degree, so we
+    // counted it twice across the loop above.
+    graph.current_cut = cut_doubled >> 1;
+    graph.boundary_count = boundary_count;
+}

package/src/core/graph/metis/native/refine/fm_kway.d.ts

@@ -0,0 +1,63 @@
+/**
+ * K-way Fiduccia–Mattheyses cut refinement (single-constraint, cut objective).
+ *
+ * For each pass:
+ *   1. Insert all boundary vertices into a max-heap keyed by
+ *      `gain = external_degree / sqrt(neighbor_partition_count) - internal_degree`.
+ *   2. Repeatedly pop the highest-gain vertex. Find the best target partition
+ *      satisfying either the standard balance bounds OR a balance-improvement
+ *      exception. Commit the move.
+ *   3. Each move incrementally updates id/ed/nbrs for the moved vertex and all
+ *      its neighbours, including queue priorities and boundary membership.
+ *
+ * The pass terminates when the heap drains or no further moves help. Multiple
+ * passes are run (default 10) until cut stops improving.
+ *
+ * Mirrors `Greedy_KWayCutOptimize` from libmetis/kwayfm.c master (post-5.1.0),
+ * OMODE_REFINE branch. Three master-era refinements over the 5.1.0 baseline:
+ *
+ *   - **Adaptive ub_factor**: at start, expand `ub_factor` to match the current
+ *     load imbalance if the graph is already worse than the configured bound.
+ *     Without this, refinement starting from an imbalanced state can't legally
+ *     act on it and gets stuck.
+ *   - **No `fudge_factor` slack** on the max-weight check (master forces this to
+ *     0 internally). The looser balance comes from the adaptive ub_factor instead.
+ *   - **Balance-improvement exception**: a move that violates the strict balance
+ *     bound is still allowed if it improves the proportional balance ratio
+ *     between `from` and `to`. Lets refinement pull weight back toward the
+ *     target over time.
+ *
+ * Skipped:
+ *   - minconn (sub-domain connectivity minimisation)
+ *   - contig (contiguous-partition articulation-point checks)
+ *   - ncon > 1 (multi-constraint balance)
+ *   - OMODE_BALANCE (we run REFINE only; the adaptive ub_factor recovers most
+ *     of what an explicit BALANCE pass would have done)
+ *
+ * Assumes `compute_kway_params` (or `project_kway`) has populated the refinement
+ * state on the graph.
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph
+ * @param {number} partition_count
+ * @param {{
+ *   random: function():number,
+ *   pass_count?: number,
+ *   ub_factor?: number,
+ *   fudge_factor?: number,
+ * }} opts
+ *   `ub_factor` (default 1.03) caps `partition_weight` at `target × ub_factor`.
+ *   Will be expanded automatically if the input is already more imbalanced.
+ *   `fudge_factor` (default 0; master sets this to 0). Set non-zero to allow
+ *   positive-gain moves to overshoot the max bound by `fudge_factor × gain`.
+ * @param {import('./RefinementScratch.js').RefinementScratch} scratch shared
+ *   scratch sized to the original (finest) graph's vertex_count and the same
+ *   partition_count used here
+ * @returns {number} total moves committed across all passes
+ */
+export function fm_kway(graph: import('../MetisGraph.js').MetisGraph, partition_count: number, opts: {
+    random: () => number;
+    pass_count?: number;
+    ub_factor?: number;
+    fudge_factor?: number;
+}, scratch: import('./RefinementScratch.js').RefinementScratch): number;
+//# sourceMappingURL=fm_kway.d.ts.map

package/src/core/graph/metis/native/refine/fm_kway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fm_kway.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/fm_kway.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,+BAjBW,OAAO,kBAAkB,EAAE,UAAU,mBACrC,MAAM;kBAEO,MAAM;iBACZ,MAAM;gBACP,MAAM;mBACH,MAAM;YAMf,OAAO,wBAAwB,EAAE,iBAAiB,GAGhD,MAAM,CAgZlB"}