@woosh/meep-engine 2.138.20 → 2.140.0

package/src/core/graph/metis/native/metis_partition_kway.js

@@ -0,0 +1,126 @@
+import { seededRandom_Mulberry32 } from "../../../math/random/seededRandom_Mulberry32.js";
+import { coarsen_graph } from "./coarsen/coarsen_graph.js";
+import { initial_kway_bfs } from "./initial/initial_kway_bfs.js";
+import { initial_kway_recursive_bisection } from "./initial/initial_kway_recursive_bisection.js";
+import { MetisGraph } from "./MetisGraph.js";
+import { compute_kway_params } from "./refine/compute_kway_params.js";
+import { refine_kway } from "./refine/refine_kway.js";
+import { RefinementScratch } from "./refine/RefinementScratch.js";
+
+/**
+ * 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,
+    partition_count,
+    edge_addresses,
+    adjacency,
+    edge_weights,
+    options
+) {
+    const raw_seed = options?.seed;
+    const seed = (raw_seed === undefined || raw_seed === -1) ? 0 : raw_seed;
+
+    const raw_pass_count = options?.niter;
+    const pass_count = (raw_pass_count === undefined || raw_pass_count === -1) ? 10 : raw_pass_count;
+
+    const raw_ufactor = options?.ufactor;
+    const ufactor = (raw_ufactor === undefined || raw_ufactor === -1) ? 30 : raw_ufactor;
+    const ub_factor = 1 + ufactor / 1000;
+
+    const initial_partition_strategy = options?.initial_partition_strategy ?? 'recursive_bisection';
+
+    const random = seededRandom_Mulberry32(seed);
+
+    if (vertex_count === 0 || partition_count <= 1) {
+        return new Uint32Array(vertex_count);
+    }
+
+    // Copy the input CSR into a MetisGraph with a single shared buffer. We
+    // can't alias the caller's arrays directly because CSRGraph owns one
+    // contiguous buffer and aliasing would split the four arrays across
+    // independent buffers, breaking copy/equals/hash. The copy cost is small
+    // relative to the partitioning work that follows.
+    const original_graph = new MetisGraph(vertex_count, edge_addresses[vertex_count]);
+    original_graph.edge_addresses.set(edge_addresses);
+    original_graph.adjacency.set(adjacency);
+    original_graph.edge_weights.set(edge_weights);
+    // vertex_weights stays at the all-1s default; total_vertex_weight = vertex_count.
+
+    // METIS heuristic for the coarsening floor: stop once we're down to about
+    // 30·k vertices (or vertex_count / (20·log2(k)), whichever is greater).
+    const coarsen_until_vertex_count = Math.max(
+        Math.ceil(vertex_count / (20 * Math.log2(Math.max(2, partition_count)))),
+        30 * partition_count
+    );
+
+    let coarsest_graph;
+    if (vertex_count <= coarsen_until_vertex_count) {
+        // Graph is already small enough; skip multilevel. Refinement still runs
+        // on this single level via the refine_kway driver.
+        coarsest_graph = original_graph;
+    } else {
+        coarsest_graph = coarsen_graph(original_graph, { random, coarsen_until_vertex_count });
+    }
+
+    if (initial_partition_strategy === 'recursive_bisection') {
+        // Recursive bisection leaves `coarsest_graph.vertex_partition` pointing
+        // at a buffer that's now owned by the graph (the BisectionScratch goes
+        // out of scope but the partition buffer survives because the graph
+        // still references it). `allocate_partition_state` preserves the
+        // existing vertex_partition, so we just install the rest of the k-way
+        // state on top.
+        initial_kway_recursive_bisection(coarsest_graph, partition_count, ub_factor, random);
+        coarsest_graph.allocate_partition_state(partition_count);
+    } else {
+        coarsest_graph.allocate_partition_state(partition_count);
+        initial_kway_bfs(coarsest_graph, partition_count, random);
+    }
+
+    compute_kway_params(coarsest_graph, partition_count);
+
+    // Shared scratch for fm_kway across every uncoarsening level. Sized to the
+    // original (finest) graph since that's the largest level we'll process.
+    const refinement_scratch = new RefinementScratch(original_graph.vertex_count, partition_count);
+
+    refine_kway(
+        original_graph,
+        coarsest_graph,
+        partition_count,
+        { random, pass_count, ub_factor },
+        refinement_scratch
+    );
+
+    return original_graph.vertex_partition;
+}

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

@@ -0,0 +1,62 @@
+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: number, initial_slot_capacity?: number);
+    __slot_capacity: number;
+    __size: number;
+    __data_buffer: ArrayBuffer;
+    __data_uint32: Uint32Array;
+    __data_float32: Float32Array;
+    /**
+     * Maps id → slot index in [0, size), or SLOT_NOT_PRESENT.
+     * @type {Uint32Array}
+     */
+    __slot_of_id: Uint32Array;
+    get size(): number;
+    /**
+     * Empty the heap. Only resets the index entries that are actually populated,
+     * so this is O(size), not O(id_capacity).
+     */
+    clear(): void;
+    contains(id: any): boolean;
+    /**
+     * Swap the entries at two slot indices, keeping the id→slot index in sync.
+     * @private
+     */
+    private __swap_slots;
+    /**
+     * Restore heap order downward starting at `start_slot`. Used when an entry's
+     * score has just decreased.
+     * @private
+     */
+    private __sift_down;
+    /**
+     * Restore heap order upward starting at `start_slot`. Used when an entry's
+     * score has just increased.
+     * @private
+     */
+    private __sift_up;
+    __grow_capacity(): void;
+    /**
+     * @param {number} id
+     * @param {number} score
+     */
+    insert(id: number, score: number): void;
+    /**
+     * @returns {number} id of the entry with the largest score, or -1 if empty
+     */
+    pop_max(): number;
+    /**
+     * @param {number} id
+     * @param {number} new_score
+     */
+    update(id: number, new_score: number): void;
+    /**
+     * @param {number} id
+     * @returns {boolean} true if the id was present and removed
+     */
+    remove(id: number): boolean;
+}
+//# sourceMappingURL=IndexedFloatMaxHeap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IndexedFloatMaxHeap.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/IndexedFloatMaxHeap.js"],"names":[],"mappings":"AA6BA;IACI;;;OAGG;IACH,yBAHW,MAAM,0BACN,MAAM,EAsBhB;IAbG,wBAA4C;IAC5C,eAAe;IAEf,2BAA4E;IAC5E,2BAAwD;IACxD,6BAA0D;IAE1D;;;OAGG;IACH,cAFU,WAAW,CAE2B;IAIpD,mBAEC;IAED;;;OAGG;IACH,cAQC;IAED,2BAEC;IAED;;;OAGG;IACH,qBAkBC;IAED;;;;OAIG;IACH,oBAsBC;IAED;;;;OAIG;IACH,kBAYC;IAED,wBAUC;IAED;;;OAGG;IACH,WAHW,MAAM,SACN,MAAM,QAehB;IAED;;OAEG;IACH,WAFa,MAAM,CAuBlB;IAED;;;OAGG;IACH,WAHW,MAAM,aACN,MAAM,QAehB;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CA+BnB;CACJ"}

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"}