@woosh/meep-engine 2.163.11 → 2.165.0

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

@@ -76,16 +76,26 @@ export class MetisGraph extends CSRGraph {
     boundary_position_of_vertex: Int32Array | null;
     /**
      * Internal degree: sum of edge weights from v to vertices in v's own
-     * partition. ("id" in METIS / FM literature.)
+     * partition. ("id" in METIS / FM literature.) Float32 because edge
+     * weights are fractional.
+     * @type {Float32Array|null}
+     */
+    internal_degree: Float32Array | null;
+    /**
+     * Number of edges (not weight) from v to vertices in v's own partition.
+     * Kept exact (integer) alongside the float `internal_degree` so that
+     * "does v still have any internal edge?" stays a precise decision under
+     * fractional weights — float-weight equality can't answer it reliably.
      * @type {Uint32Array|null}
      */
-    internal_degree: Uint32Array | null;
+    internal_edge_count: Uint32Array | null;
     /**
      * External degree: sum of edge weights from v to vertices in other
-     * partitions. ("ed" in METIS / FM literature.)
-     * @type {Uint32Array|null}
+     * partitions. ("ed" in METIS / FM literature.) Float32 because edge
+     * weights are fractional.
+     * @type {Float32Array|null}
      */
-    external_degree: Uint32Array | null;
+    external_degree: Float32Array | null;
     /**
      * Number of distinct neighbouring partitions reachable from v through
      * its edges. ("nnbrs" in METIS.)
@@ -101,11 +111,17 @@ export class MetisGraph extends CSRGraph {
     neighbor_partition_offset: Int32Array | null;
     /**
      * Pool of per-(vertex, neighbour-partition) records. Each record is
-     * 8 bytes: two uint32 words holding `(partition_id, edge_weight)`.
-     * Access record `r` via:
-     *   const word_base = neighbor_partition_pool.element_word(r);
-     *   const partition_id  = data_uint32[word_base + 2*k    ];
-     *   const edge_weight   = data_uint32[word_base + 2*k + 1];
+     * 12 bytes: three 4-byte words holding `(partition_id, edge_weight, edge_count)`.
+     * `partition_id` and `edge_count` are uint32; `edge_weight` is float32 —
+     * read it through the pool's `data_float32` view, the other two through
+     * `data_uint32`. `edge_count` is the exact number of edges summed into
+     * `edge_weight`; add/remove decisions key off it (not off weight equality)
+     * so they stay precise under fractional weights. Access entry `k` of
+     * vertex v's list via:
+     *   const word_base = neighbor_partition_pool.element_word(offset);
+     *   const partition_id = data_uint32 [word_base + 3*k    ];
+     *   const edge_weight  = data_float32[word_base + 3*k + 1];
+     *   const edge_count   = data_uint32 [word_base + 3*k + 2];
      * where `k` is in `[0, neighbor_partition_count[v])`.
      *
      * ("cnbrpool" in METIS.)

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

@@ -1 +1 @@
-{"version":3,"file":"MetisGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/metis/native/MetisGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAWQ;;;;OAIG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B,8BAA8B;IAC9B,eADW,UAAU,GAAC,IAAI,CACD;IACzB,8BAA8B;IAC9B,aADW,UAAU,GAAC,IAAI,CACH;IAIvB;;;OAGG;IACH,kBAFU,WAAW,GAAC,IAAI,CAEE;IAE5B;;;;OAIG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B;;;;;OAKG;IACH,6BAFU,UAAU,GAAC,IAAI,CAEc;IAIvC;;;;OAIG;IACH,iBAFU,WAAW,GAAC,IAAI,CAEC;IAE3B;;;;OAIG;IACH,iBAFU,WAAW,GAAC,IAAI,CAEC;IAE3B;;;;OAIG;IACH,0BAFU,WAAW,GAAC,IAAI,CAEU;IAEpC;;;;;OAKG;IACH,2BAFU,UAAU,GAAC,IAAI,CAEY;IAErC;;;;;;;;;;;;OAYG;IACH,yBAFU,iBAAiB,GAAC,IAAI,CAEG;IAGvC;;;;;;;;;;;;;;;;OAgBG;IACH,0CAFW,MAAM,QAyBhB;IAED;;;;OAIG;IACH,+BAcC;IAGL,sBAAiC;CAFhC;yBA/MwB,uBAAuB;kCADd,8DAA8D"}
+{"version":3,"file":"MetisGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/core/graph/metis/native/MetisGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAWQ;;;;OAIG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B,8BAA8B;IAC9B,eADW,UAAU,GAAC,IAAI,CACD;IACzB,8BAA8B;IAC9B,aADW,UAAU,GAAC,IAAI,CACH;IAIvB;;;OAGG;IACH,kBAFU,WAAW,GAAC,IAAI,CAEE;IAE5B;;;;OAIG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,mBAFU,WAAW,GAAC,IAAI,CAEG;IAE7B;;;;;OAKG;IACH,6BAFU,UAAU,GAAC,IAAI,CAEc;IAIvC;;;;;OAKG;IACH,iBAFU,YAAY,GAAC,IAAI,CAEA;IAE3B;;;;;;OAMG;IACH,qBAFU,WAAW,GAAC,IAAI,CAEK;IAE/B;;;;;OAKG;IACH,iBAFU,YAAY,GAAC,IAAI,CAEA;IAE3B;;;;OAIG;IACH,0BAFU,WAAW,GAAC,IAAI,CAEU;IAEpC;;;;;OAKG;IACH,2BAFU,UAAU,GAAC,IAAI,CAEY;IAErC;;;;;;;;;;;;;;;;;;OAkBG;IACH,yBAFU,iBAAiB,GAAC,IAAI,CAEG;IAGvC;;;;;;;;;;;;;;;;OAgBG;IACH,0CAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,+BAeC;IAGL,sBAAiC;CAFhC;yBAlOwB,uBAAuB;kCADd,8DAA8D"}

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

@@ -102,16 +102,27 @@ export class MetisGraph extends CSRGraph {
 
         /**
          * Internal degree: sum of edge weights from v to vertices in v's own
-         * partition. ("id" in METIS / FM literature.)
-         * @type {Uint32Array|null}
+         * partition. ("id" in METIS / FM literature.) Float32 because edge
+         * weights are fractional.
+         * @type {Float32Array|null}
          */
         this.internal_degree = null;
 
         /**
-         * External degree: sum of edge weights from v to vertices in other
-         * partitions. ("ed" in METIS / FM literature.)
+         * Number of edges (not weight) from v to vertices in v's own partition.
+         * Kept exact (integer) alongside the float `internal_degree` so that
+         * "does v still have any internal edge?" stays a precise decision under
+         * fractional weights — float-weight equality can't answer it reliably.
          * @type {Uint32Array|null}
          */
+        this.internal_edge_count = null;
+
+        /**
+         * External degree: sum of edge weights from v to vertices in other
+         * partitions. ("ed" in METIS / FM literature.) Float32 because edge
+         * weights are fractional.
+         * @type {Float32Array|null}
+         */
         this.external_degree = null;
 
         /**
@@ -131,11 +142,17 @@ export class MetisGraph extends CSRGraph {
 
         /**
          * Pool of per-(vertex, neighbour-partition) records. Each record is
-         * 8 bytes: two uint32 words holding `(partition_id, edge_weight)`.
-         * Access record `r` via:
-         *   const word_base = neighbor_partition_pool.element_word(r);
-         *   const partition_id  = data_uint32[word_base + 2*k    ];
-         *   const edge_weight   = data_uint32[word_base + 2*k + 1];
+         * 12 bytes: three 4-byte words holding `(partition_id, edge_weight, edge_count)`.
+         * `partition_id` and `edge_count` are uint32; `edge_weight` is float32 —
+         * read it through the pool's `data_float32` view, the other two through
+         * `data_uint32`. `edge_count` is the exact number of edges summed into
+         * `edge_weight`; add/remove decisions key off it (not off weight equality)
+         * so they stay precise under fractional weights. Access entry `k` of
+         * vertex v's list via:
+         *   const word_base = neighbor_partition_pool.element_word(offset);
+         *   const partition_id = data_uint32 [word_base + 3*k    ];
+         *   const edge_weight  = data_float32[word_base + 3*k + 1];
+         *   const edge_count   = data_uint32 [word_base + 3*k + 2];
          * where `k` is in `[0, neighbor_partition_count[v])`.
          *
          * ("cnbrpool" in METIS.)
@@ -175,16 +192,17 @@ export class MetisGraph extends CSRGraph {
         this.boundary_position_of_vertex = new Int32Array(n);
         this.boundary_position_of_vertex.fill(-1);
 
-        this.internal_degree = new Uint32Array(n);
-        this.external_degree = new Uint32Array(n);
+        this.internal_degree = new Float32Array(n);
+        this.internal_edge_count = new Uint32Array(n);
+        this.external_degree = new Float32Array(n);
         this.neighbor_partition_count = new Uint32Array(n);
         this.neighbor_partition_offset = new Int32Array(n);
         this.neighbor_partition_offset.fill(-1);
 
-        // Each pool record is 8 bytes (uint32 partition_id, uint32 edge_weight).
-        // Initial capacity sized to the adjacency length as a rough upper bound;
-        // the pool grows on demand.
-        this.neighbor_partition_pool = new BinaryElementPool(8, Math.max(64, this.adjacency_length));
+        // Each pool record is 12 bytes (uint32 partition_id, float32 edge_weight,
+        // uint32 edge_count). Initial capacity sized to the adjacency length as a
+        // rough upper bound; the pool grows on demand.
+        this.neighbor_partition_pool = new BinaryElementPool(12, Math.max(64, this.adjacency_length));
     }
 
     /**
@@ -195,6 +213,7 @@ export class MetisGraph extends CSRGraph {
     reset_refinement_state() {
         if (this.internal_degree !== null) {
             this.internal_degree.fill(0);
+            this.internal_edge_count.fill(0);
             this.external_degree.fill(0);
             this.neighbor_partition_count.fill(0);
             this.neighbor_partition_offset.fill(-1);

package/src/core/graph/metis/native/bisection/BisectionScratch.d.ts

@@ -39,8 +39,8 @@ export class BisectionScratch {
     max_vertex_count: number;
     boundary_vertices: Uint32Array;
     boundary_position_of_vertex: Int32Array;
-    internal_degree: Uint32Array;
-    external_degree: Uint32Array;
+    internal_degree: Float32Array;
+    external_degree: Float32Array;
     partition_weights: Uint32Array;
     best_partition_snapshot: Uint32Array;
     fm_heaps: IndexedFloatMaxHeap[];

package/src/core/graph/metis/native/bisection/BisectionScratch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BisectionScratch.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/bisection/BisectionScratch.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACI;;OAEG;IACH,8BAFW,MAAM,EA8BhB;IA3BG,yBAAwC;IAIxC,+BAA0D;IAC1D,wCAAmE;IACnE,6BAAwD;IACxD,6BAAwD;IACxD,+BAA2C;IAC3C,qCAAgE;IAIhE,gCAGC;IACD,gCAA2D;IAE3D,6BAAwD;IACxD,gCAA2D;IAI3D,4BAA4B;IAC5B,uBADW,WAAW,EAAE,CACO;IAC/B,kCAAkC;IAGtC;;;;;;;;;;OAUG;IACH,yCAHW,MAAM,GACJ,WAAW,CAavB;IAED;;;OAGG;IACH,sCAEC;CACJ;oCApGmC,oDAAoD"}
+{"version":3,"file":"BisectionScratch.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/bisection/BisectionScratch.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACI;;OAEG;IACH,8BAFW,MAAM,EAgChB;IA7BG,yBAAwC;IAIxC,+BAA0D;IAC1D,wCAAmE;IAGnE,8BAAyD;IACzD,8BAAyD;IACzD,+BAA2C;IAC3C,qCAAgE;IAIhE,gCAGC;IACD,gCAA2D;IAE3D,6BAAwD;IACxD,gCAA2D;IAI3D,4BAA4B;IAC5B,uBADW,WAAW,EAAE,CACO;IAC/B,kCAAkC;IAGtC;;;;;;;;;;OAUG;IACH,yCAHW,MAAM,GACJ,WAAW,CAavB;IAED;;;OAGG;IACH,sCAEC;CACJ;oCAtGmC,oDAAoD"}

package/src/core/graph/metis/native/bisection/BisectionScratch.js

@@ -44,8 +44,10 @@ export class BisectionScratch {
 
         this.boundary_vertices = new Uint32Array(max_vertex_count);
         this.boundary_position_of_vertex = new Int32Array(max_vertex_count);
-        this.internal_degree = new Uint32Array(max_vertex_count);
-        this.external_degree = new Uint32Array(max_vertex_count);
+        // id/ed accumulate fractional edge weights, so they're float. partition_weights
+        // sums vertex weights, which stay integer.
+        this.internal_degree = new Float32Array(max_vertex_count);
+        this.external_degree = new Float32Array(max_vertex_count);
         this.partition_weights = new Uint32Array(2);
         this.best_partition_snapshot = new Uint32Array(max_vertex_count);
 

package/src/core/graph/metis/native/bisection/compute_2way_params.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_2way_params.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/bisection/compute_2way_params.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,2CAFW,OAAO,kBAAkB,EAAE,UAAU,QAsE/C"}
+{"version":3,"file":"compute_2way_params.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/bisection/compute_2way_params.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,2CAFW,OAAO,kBAAkB,EAAE,UAAU,QAwE/C"}

package/src/core/graph/metis/native/bisection/compute_2way_params.js

@@ -79,6 +79,8 @@ export function compute_2way_params(graph) {
         }
     }
 
-    graph.current_cut = cut_doubled >> 1;
+    // /2 not >>1: cut_doubled is exactly twice the cut (each crossing edge counted
+    // at both endpoints), and may be fractional now that edge weights are float.
+    graph.current_cut = cut_doubled / 2;
     graph.boundary_count = boundary_count;
 }

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

@@ -14,7 +14,7 @@
  * @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 {Float32Array} edge_weights parallel to adjacency; fractional weights are supported
  * @param {{
  *   seed?: number,
  *   niter?: number,
@@ -32,7 +32,7 @@
  *     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?: {
+export function metis_partition_kway(vertex_count: number, partition_count: number, edge_addresses: Uint32Array, adjacency: Uint32Array, edge_weights: Float32Array, options?: {
     seed?: number;
     niter?: number;
     ufactor?: number;

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

@@ -1 +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"}
+{"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,YAAY;WAEX,MAAM;YACL,MAAM;cACJ,MAAM;iCACa,qBAAqB,GAAG,KAAK;IAWlD,WAAW,CAoFvB"}

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

@@ -23,7 +23,7 @@ import { RefinementScratch } from "./refine/RefinementScratch.js";
  * @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 {Float32Array} edge_weights parallel to adjacency; fractional weights are supported
  * @param {{
  *   seed?: number,
  *   niter?: number,

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

@@ -1 +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,QA0HhB"}
+{"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,QAsIhB"}

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

@@ -25,6 +25,7 @@ export function compute_kway_params(graph, partition_count) {
     const vertex_partition = graph.vertex_partition;
     const partition_weights = graph.partition_weights;
     const internal_degree = graph.internal_degree;
+    const internal_edge_count = graph.internal_edge_count;
     const external_degree = graph.external_degree;
     const neighbor_partition_count = graph.neighbor_partition_count;
     const neighbor_partition_offset = graph.neighbor_partition_offset;
@@ -37,6 +38,7 @@ export function compute_kway_params(graph, partition_count) {
 
     partition_weights.fill(0);
     internal_degree.fill(0);
+    internal_edge_count.fill(0);
     external_degree.fill(0);
     neighbor_partition_count.fill(0);
     neighbor_partition_offset.fill(-1);
@@ -61,7 +63,10 @@ export function compute_kway_params(graph, partition_count) {
     // 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);
+    const scratch_partition_edge_weight = new Float32Array(partition_count);
+    // Exact count of edges summed into each scratch weight; copied into the pool
+    // so downstream add/remove decisions key off counts, not float-weight equality.
+    const scratch_partition_edge_count = new Uint32Array(partition_count);
 
     let boundary_count = 0;
     let cut_doubled = 0;
@@ -70,6 +75,7 @@ export function compute_kway_params(graph, partition_count) {
         const my_partition = vertex_partition[vertex];
 
         let v_internal_degree = 0;
+        let v_internal_edge_count = 0;
         let v_external_degree = 0;
         let distinct_neighbor_partitions = 0;
 
@@ -80,6 +86,7 @@ export function compute_kway_params(graph, partition_count) {
             const edge_weight = edge_weights[edge_offset];
             if (neighbor_partition === my_partition) {
                 v_internal_degree += edge_weight;
+                v_internal_edge_count++;
             } else {
                 v_external_degree += edge_weight;
                 const existing_position = scratch_partition_position[neighbor_partition];
@@ -87,14 +94,17 @@ export function compute_kway_params(graph, partition_count) {
                     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;
+                    scratch_partition_edge_count[distinct_neighbor_partitions] = 1;
                     distinct_neighbor_partitions++;
                 } else {
                     scratch_partition_edge_weight[existing_position] += edge_weight;
+                    scratch_partition_edge_count[existing_position]++;
                 }
             }
         }
 
         internal_degree[vertex] = v_internal_degree;
+        internal_edge_count[vertex] = v_internal_edge_count;
         external_degree[vertex] = v_external_degree;
 
         if (v_external_degree > 0) {
@@ -106,17 +116,19 @@ export function compute_kway_params(graph, partition_count) {
             // and introduce a new partition; we need room.
             const degree = edge_end - edge_start;
             const pool_record_offset = neighbor_partition_pool.allocate_continuous(degree);
-            // Re-read the backing view AFTER allocating: allocate_continuous may have grown the pool and
-            // replaced data_uint32, leaving any previously-captured view pointing at a detached (stale) buffer.
+            // Re-read BOTH backing views AFTER allocating: allocate_continuous may have grown the pool and
+            // replaced the buffer, leaving any previously-captured view pointing at a detached (stale) buffer.
             const pool_data = neighbor_partition_pool.data_uint32;
+            const pool_data_f32 = neighbor_partition_pool.data_float32;
             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).
+            // Each pool record is 3 words: (partition_id:u32, edge_weight:f32, edge_count:u32).
             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];
+                pool_data[word_base + nbr * 3] = scratch_partition_id[nbr];
+                pool_data_f32[word_base + nbr * 3 + 1] = scratch_partition_edge_weight[nbr];
+                pool_data[word_base + nbr * 3 + 2] = scratch_partition_edge_count[nbr];
             }
 
             if (v_external_degree >= v_internal_degree) {
@@ -133,7 +145,7 @@ export function compute_kway_params(graph, partition_count) {
     }
 
     // Each crossing edge contributes to both endpoints' external_degree, so we
-    // counted it twice across the loop above.
-    graph.current_cut = cut_doubled >> 1;
+    // counted it twice across the loop above. /2 not >>1: the cut may be fractional.
+    graph.current_cut = cut_doubled / 2;
     graph.boundary_count = boundary_count;
 }

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

@@ -1 +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"}
+{"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,CAyalB"}

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

@@ -77,6 +77,7 @@ export function fm_kway(graph, partition_count, opts, scratch) {
     const boundary_vertices = graph.boundary_vertices;
     const boundary_position_of_vertex = graph.boundary_position_of_vertex;
     const internal_degree = graph.internal_degree;
+    const internal_edge_count = graph.internal_edge_count;
     const external_degree = graph.external_degree;
     const neighbor_partition_count = graph.neighbor_partition_count;
     const neighbor_partition_offset = graph.neighbor_partition_offset;
@@ -169,6 +170,7 @@ export function fm_kway(graph, partition_count, opts, scratch) {
             const from_partition = vertex_partition[vertex];
             const vertex_weight = vertex_weights[vertex];
             const v_internal_degree = internal_degree[vertex];
+            const v_internal_edge_count = internal_edge_count[vertex];
             const v_external_degree = external_degree[vertex];
             const v_nbr_partition_count = neighbor_partition_count[vertex];
             const v_pool_offset = neighbor_partition_offset[vertex];
@@ -189,15 +191,19 @@ export function fm_kway(graph, partition_count, opts, scratch) {
             // The balance-improvement test `pwgts[from] - vwgt > pwgts[to]`
             // is master's `tpwgts[from]*pwgts[to] < tpwgts[to]*(pwgts[from]-vwgt)`
             // simplified for uniform tpwgts (which is all we support).
+            // Pool records are 3 words: id (u32), weight (f32), count (u32). Read ids/counts
+            // through pool_data, weights through pool_data_f32. No allocation happens between
+            // here and the commit below, so these views stay valid for v's region.
             const pool_data = neighbor_partition_pool.data_uint32;
+            const pool_data_f32 = neighbor_partition_pool.data_float32;
             const v_pool_word_base = neighbor_partition_pool.element_word(v_pool_offset);
 
             const partition_weight_from_after = partition_weights[from_partition] - vertex_weight;
 
             let best_nbr_index = -1;
             for (let nbr_index = v_nbr_partition_count - 1; nbr_index >= 0; nbr_index--) {
-                const candidate_partition = pool_data[v_pool_word_base + nbr_index * 2];
-                const candidate_edge_weight = pool_data[v_pool_word_base + nbr_index * 2 + 1];
+                const candidate_partition = pool_data[v_pool_word_base + nbr_index * 3];
+                const candidate_edge_weight = pool_data_f32[v_pool_word_base + nbr_index * 3 + 1];
                 const candidate_weight_after = partition_weights[candidate_partition] + vertex_weight;
 
                 // "Move improves proportional balance" (uniform-tpwgts form).
@@ -220,11 +226,11 @@ export function fm_kway(graph, partition_count, opts, scratch) {
             }
 
             {
-                let best_edge_weight = pool_data[v_pool_word_base + best_nbr_index * 2 + 1];
-                let best_target_partition = pool_data[v_pool_word_base + best_nbr_index * 2];
+                let best_edge_weight = pool_data_f32[v_pool_word_base + best_nbr_index * 3 + 1];
+                let best_target_partition = pool_data[v_pool_word_base + best_nbr_index * 3];
                 for (let nbr_index = best_nbr_index - 1; nbr_index >= 0; nbr_index--) {
-                    const candidate_partition = pool_data[v_pool_word_base + nbr_index * 2];
-                    const candidate_edge_weight = pool_data[v_pool_word_base + nbr_index * 2 + 1];
+                    const candidate_partition = pool_data[v_pool_word_base + nbr_index * 3];
+                    const candidate_edge_weight = pool_data_f32[v_pool_word_base + nbr_index * 3 + 1];
                     const candidate_weight_after = partition_weights[candidate_partition] + vertex_weight;
                     const balance_improves = candidate_weight_after - vertex_weight < partition_weight_from_after;
 
@@ -245,8 +251,9 @@ export function fm_kway(graph, partition_count, opts, scratch) {
                 }
             }
 
-            const to_partition = pool_data[v_pool_word_base + best_nbr_index * 2];
-            const to_edge_weight = pool_data[v_pool_word_base + best_nbr_index * 2 + 1];
+            const to_partition = pool_data[v_pool_word_base + best_nbr_index * 3];
+            const to_edge_weight = pool_data_f32[v_pool_word_base + best_nbr_index * 3 + 1];
+            const to_edge_count = pool_data[v_pool_word_base + best_nbr_index * 3 + 2];
             const gain = to_edge_weight - v_internal_degree;
 
             // ===== Commit the move =========================================
@@ -266,21 +273,26 @@ export function fm_kway(graph, partition_count, opts, scratch) {
             const new_internal_degree = to_edge_weight;
             const new_external_degree = v_external_degree - to_edge_weight + v_internal_degree;
             internal_degree[vertex] = new_internal_degree;
+            // v's internal edges are now exactly the ones that used to go to `to_partition`.
+            internal_edge_count[vertex] = to_edge_count;
             external_degree[vertex] = new_external_degree;
 
-            if (v_internal_degree === 0) {
-                // No back-edges to `from_partition`. Drop the entry by swap-with-last.
+            if (v_internal_edge_count === 0) {
+                // No back-edges to `from_partition` (exact edge-count test, not a float
+                // weight test). Drop the entry by swap-with-last; copy all three words.
                 const last_index = v_nbr_partition_count - 1;
                 if (best_nbr_index !== last_index) {
-                    pool_data[v_pool_word_base + best_nbr_index * 2]     = pool_data[v_pool_word_base + last_index * 2];
-                    pool_data[v_pool_word_base + best_nbr_index * 2 + 1] = pool_data[v_pool_word_base + last_index * 2 + 1];
+                    pool_data    [v_pool_word_base + best_nbr_index * 3]     = pool_data    [v_pool_word_base + last_index * 3];
+                    pool_data_f32[v_pool_word_base + best_nbr_index * 3 + 1] = pool_data_f32[v_pool_word_base + last_index * 3 + 1];
+                    pool_data    [v_pool_word_base + best_nbr_index * 3 + 2] = pool_data    [v_pool_word_base + last_index * 3 + 2];
                 }
                 neighbor_partition_count[vertex] = last_index;
             } else {
                 // The slot that used to represent `to_partition` now represents
-                // `from_partition` with the old internal_degree as its edge weight.
-                pool_data[v_pool_word_base + best_nbr_index * 2] = from_partition;
-                pool_data[v_pool_word_base + best_nbr_index * 2 + 1] = v_internal_degree;
+                // `from_partition` with the old internal degree/count as its edge data.
+                pool_data    [v_pool_word_base + best_nbr_index * 3]     = from_partition;
+                pool_data_f32[v_pool_word_base + best_nbr_index * 3 + 1] = v_internal_degree;
+                pool_data    [v_pool_word_base + best_nbr_index * 3 + 2] = v_internal_edge_count;
             }
 
             // Update v's boundary membership.
@@ -318,11 +330,13 @@ export function fm_kway(graph, partition_count, opts, scratch) {
                     neighbor_pool_offset = neighbor_partition_pool.allocate_continuous(neighbor_degree);
                     neighbor_partition_offset[neighbor] = neighbor_pool_offset;
                 }
-                // Re-fetch the data view in case the pool grew during allocate.
+                // Re-fetch BOTH data views in case the pool grew during allocate.
                 const pool_data_for_neighbor = neighbor_partition_pool.data_uint32;
+                const pool_data_for_neighbor_f32 = neighbor_partition_pool.data_float32;
                 const neighbor_pool_word_base = neighbor_partition_pool.element_word(neighbor_pool_offset);
 
                 let n_internal_degree = internal_degree[neighbor];
+                let n_internal_edge_count = internal_edge_count[neighbor];
                 let n_external_degree = external_degree[neighbor];
                 let n_nbr_partition_count = neighbor_partition_count[neighbor];
 
@@ -330,56 +344,67 @@ export function fm_kway(graph, partition_count, opts, scratch) {
                     // The edge v–neighbor used to be internal for the neighbour
                     // (both in `from`); after v's move it becomes external.
                     n_internal_degree -= edge_weight_to_neighbor;
+                    n_internal_edge_count--;
                     n_external_degree += edge_weight_to_neighbor;
                 } else if (neighbor_owning_partition === to_partition) {
                     // The reverse — was external, now internal.
                     n_internal_degree += edge_weight_to_neighbor;
+                    n_internal_edge_count++;
                     n_external_degree -= edge_weight_to_neighbor;
                 }
 
-                // Remove the neighbour's record of `from_partition` (or
-                // decrement it). Only do this if the neighbour is not itself
-                // in `from_partition`; if it is, `from` isn't in its neighbour
-                // list at all.
+                // Remove the neighbour's record of `from_partition` (or decrement it).
+                // Only do this if the neighbour is not itself in `from_partition`; if it
+                // is, `from` isn't in its neighbour list at all. The v–neighbor edge is
+                // exactly one edge into `from`, so drop the entry's edge count by 1 and
+                // remove the entry only when that count hits 0 — an exact decision, not
+                // the float weight comparison that fractional weights would make unsafe.
                 if (neighbor_owning_partition !== from_partition) {
                     for (let nbr_index = 0; nbr_index < n_nbr_partition_count; nbr_index++) {
-                        if (pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2] === from_partition) {
-                            const current_edge_weight = pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2 + 1];
-                            if (current_edge_weight === edge_weight_to_neighbor) {
-                                // Last edge to from-partition; remove the entry.
+                        if (pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 3] === from_partition) {
+                            const remaining_count = pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 3 + 2] - 1;
+                            if (remaining_count === 0) {
+                                // Last edge to from-partition; remove the entry by swap-with-last.
                                 const last_index = n_nbr_partition_count - 1;
                                 if (nbr_index !== last_index) {
-                                    pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2]     = pool_data_for_neighbor[neighbor_pool_word_base + last_index * 2];
-                                    pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2 + 1] = pool_data_for_neighbor[neighbor_pool_word_base + last_index * 2 + 1];
+                                    pool_data_for_neighbor    [neighbor_pool_word_base + nbr_index * 3]     = pool_data_for_neighbor    [neighbor_pool_word_base + last_index * 3];
+                                    pool_data_for_neighbor_f32[neighbor_pool_word_base + nbr_index * 3 + 1] = pool_data_for_neighbor_f32[neighbor_pool_word_base + last_index * 3 + 1];
+                                    pool_data_for_neighbor    [neighbor_pool_word_base + nbr_index * 3 + 2] = pool_data_for_neighbor    [neighbor_pool_word_base + last_index * 3 + 2];
                                 }
                                 n_nbr_partition_count = last_index;
                             } else {
-                                pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2 + 1] = current_edge_weight - edge_weight_to_neighbor;
+                                const current_edge_weight = pool_data_for_neighbor_f32[neighbor_pool_word_base + nbr_index * 3 + 1];
+                                pool_data_for_neighbor_f32[neighbor_pool_word_base + nbr_index * 3 + 1] = current_edge_weight - edge_weight_to_neighbor;
+                                pool_data_for_neighbor    [neighbor_pool_word_base + nbr_index * 3 + 2] = remaining_count;
                             }
                             break;
                         }
                     }
                 }
 
-                // Add or increment the neighbour's record of `to_partition`,
-                // unless the neighbour is itself in `to_partition`.
+                // Add or increment the neighbour's record of `to_partition`, unless the
+                // neighbour is itself in `to_partition`. The v–neighbor edge adds exactly
+                // one edge into `to`, so bump the entry's edge count by 1.
                 if (neighbor_owning_partition !== to_partition) {
                     let found_existing_entry = false;
                     for (let nbr_index = 0; nbr_index < n_nbr_partition_count; nbr_index++) {
-                        if (pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2] === to_partition) {
-                            pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 2 + 1] += edge_weight_to_neighbor;
+                        if (pool_data_for_neighbor[neighbor_pool_word_base + nbr_index * 3] === to_partition) {
+                            pool_data_for_neighbor_f32[neighbor_pool_word_base + nbr_index * 3 + 1] += edge_weight_to_neighbor;
+                            pool_data_for_neighbor    [neighbor_pool_word_base + nbr_index * 3 + 2] += 1;
                             found_existing_entry = true;
                             break;
                         }
                     }
                     if (!found_existing_entry) {
-                        pool_data_for_neighbor[neighbor_pool_word_base + n_nbr_partition_count * 2]     = to_partition;
-                        pool_data_for_neighbor[neighbor_pool_word_base + n_nbr_partition_count * 2 + 1] = edge_weight_to_neighbor;
+                        pool_data_for_neighbor    [neighbor_pool_word_base + n_nbr_partition_count * 3]     = to_partition;
+                        pool_data_for_neighbor_f32[neighbor_pool_word_base + n_nbr_partition_count * 3 + 1] = edge_weight_to_neighbor;
+                        pool_data_for_neighbor    [neighbor_pool_word_base + n_nbr_partition_count * 3 + 2] = 1;
                         n_nbr_partition_count++;
                     }
                 }
 
                 internal_degree[neighbor] = n_internal_degree;
+                internal_edge_count[neighbor] = n_internal_edge_count;
                 external_degree[neighbor] = n_external_degree;
                 neighbor_partition_count[neighbor] = n_nbr_partition_count;
 

package/src/core/math/linalg/cg/cg_solve.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Conjugate Gradient solve of `A x = b` for a symmetric positive-definite
+ * operator `A`, supplied as a matrix-free callback. This is the generic core
+ * shared by the cotangent-Laplacian harmonic solve and the LSCM normal
+ * equations (via {@link cg_solve_normal_equations}).
+ *
+ * `x` is both the initial guess and the output (warm-start it with a prior
+ * solution to cut iterations; zero-fill for a cold start). Convergence is the
+ * relative residual: the solve stops when `‖r‖ <= tolerance · ‖r0‖`.
+ *
+ * Determinism: reductions run in fixed index order with no wall-clock exit, so
+ * the result is bit-reproducible for a given `apply_A`.
+ *
+ * @param {Float64Array} x length n; initial guess in, solution out
+ * @param {(out: Float64Array, vec: Float64Array) => void} apply_A computes out = A·vec
+ *   over the first n entries
+ * @param {Float64Array} b right-hand side, length n
+ * @param {number} n system size
+ * @param {number} max_iterations hard cap on iterations
+ * @param {number} tolerance relative residual target in [0, 1]; 0 runs to max_iterations
+ * @returns {number} iterations performed
+ */
+export function cg_solve(x: Float64Array, apply_A: (out: Float64Array, vec: Float64Array) => void, b: Float64Array, n: number, max_iterations: number, tolerance: number): number;
+//# sourceMappingURL=cg_solve.d.ts.map

package/src/core/math/linalg/cg/cg_solve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cg_solve.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/cg/cg_solve.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4BATW,YAAY,iBACN,YAAY,OAAO,YAAY,KAAK,IAAI,KAE9C,YAAY,KACZ,MAAM,kBACN,MAAM,aACN,MAAM,GACJ,MAAM,CA6DlB"}