@graphty/webgpu-graph-algorithms 0.5.0 → 0.5.1

package/dist/src/types/options.d.ts

@@ -5,7 +5,7 @@
  * `ResolvedForceAtlas2Options` below is this package's own and stays local. Types only: nothing here is a runtime
  * import.
  */
-import type { F32, NodeId } from "@graphty/graph-format";
+import type { F32, NodeId, NodeMask } from "@graphty/graph-format";
 import type { CommonLayoutOptions, ForceAtlas2Options, FruchtermanReingoldOptions, SimulationOptions, SpringElectricalOptions } from "@graphty/layout";
 export type { CommonLayoutOptions, ForceAtlas2Options, FruchtermanReingoldOptions, SimulationOptions, SpringElectricalOptions, };
 /**
@@ -34,4 +34,46 @@ export interface ResolvedForceAtlas2Options {
     readonly iterationsPerStep: number;
     readonly maxInFlight: number;
 }
+/**
+ * The resolved (defaults applied) Fruchterman-Reingold option record (spec 7.20, 9.3): `k` null means `1 / sqrt(n)`
+ * at load; `fixed` is applied at load through ModelInputs.fixed (PD-6). Exported for src/layouts/fruchterman-reingold.ts
+ * and the option tests.
+ * @public
+ */
+export interface ResolvedFruchtermanReingoldOptions {
+    readonly k: number | null;
+    readonly iterations: number;
+    readonly cooling: "linear" | "adaptive";
+    readonly fixed: NodeMask | string | null;
+    readonly dim: 2 | 3;
+    readonly scale: number;
+    readonly center: readonly [number, number, number];
+    readonly seed: number | null;
+    readonly settleThreshold: number;
+    readonly settleWindow: number;
+    readonly iterationsPerStep: number;
+    readonly maxInFlight: number;
+}
+/**
+ * The resolved spring-electrical option record (spec 7.20, 9.3; ngraph's names): `gravity` is the Coulomb constant
+ * (negative repels), never FA2's centre gravity. `gravity` and `springCoefficient` are null when left to their
+ * defaults: ngraph's constant scaled by min(1, SE_SCALE_REFERENCE_NODES / n) once n is known at load. Exported for
+ * src/layouts/spring-electrical.ts and the option tests.
+ * @public
+ */
+export interface ResolvedSpringElectricalOptions {
+    readonly springLength: number;
+    readonly springCoefficient: number | null;
+    readonly gravity: number | null;
+    readonly dragCoefficient: number;
+    readonly timeStep: number;
+    readonly dim: 2 | 3;
+    readonly scale: number;
+    readonly center: readonly [number, number, number];
+    readonly seed: number | null;
+    readonly settleThreshold: number;
+    readonly settleWindow: number;
+    readonly iterationsPerStep: number;
+    readonly maxInFlight: number;
+}
 //# sourceMappingURL=options.d.ts.map

package/dist/src/types/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/types/options.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EACR,mBAAmB,EACnB,kBAAkB,EAClB,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,EAC1B,MAAM,iBAAiB,CAAC;AAIzB,YAAY,EACR,mBAAmB,EACnB,kBAAkB,EAClB,0BAA0B,EAC1B,iBAAiB,EACjB,uBAAuB,GAC1B,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1E,QAAQ,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1E,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAChC"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/types/options.ts"],"names":[],"mappings":"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"}

package/dist/src/wgsl/fa2-attraction.wgsl.d.ts

@@ -3,10 +3,13 @@
  * attraction force over the undirected CSR rows (both arcs present, so the sum is symmetric with no atomics), the
  * linear or linlog law, the optional weights, the distributed-action division by the mass in `pos.w`, written as
  * the FIRST writer of `force` each iteration. P3 ships the thread-per-row tier over `[tierStart, tierEnd)` = `[0, n)`
- * with `USE_PERM = false`; the subgroup / workgroup tiers arrive with P4 (`TIER`).
+ * with `USE_PERM = false`; the subgroup / workgroup tiers arrive with P4 (`TIER`). `LAW` (P5, spec 7.20) picks the
+ * pair law: 0 = the FA2 text, 1 = Fruchterman-Reingold `d^2 / k` (unfloored), 2 = ngraph's Hooke spring
+ * `k_s (d - L)`; under 1 / 2 the models compile `LINLOG = false` and `HAS_WEIGHTS = false`, and the law overwrites
+ * `w` so weights are ignored either way.
  *
  * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5) are textual edits of it.
  */
 /** The K2 body: entry point `attraction`; an early return is legal here because no barrier follows (spec 3.5 rule 1). */
-export declare const fa2AttractionWgsl = "fn store_force(i: u32, f: vec3f) {\n    force[3u * i] = f.x;\n    force[3u * i + 1u] = f.y;\n    force[3u * i + 2u] = f.z;\n}\n\n@compute @workgroup_size(WG)\nfn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let row = linear_id(wid, lid.x) + P.tierStart;\n    if (row >= P.tierEnd) { return; }                          // no barrier follows in this tier (3.5 rule 1)\n    let i = select(row, perm[row], USE_PERM);\n    let pi = pos[i];                                           // xyz + mass in one load (D23)\n    var f = vec3f(0.0);\n    for (var a = rowPtr[i]; a < rowPtr[i + 1u]; a = a + 1u) {\n        let j = colIdx[a];\n        if (j == i) { continue; }                              // a self-loop exerts no force\n        var w = 1.0;\n        if (HAS_WEIGHTS) { w = weights[a]; }\n        let d = pos[j].xyz - pi.xyz;                           // toward j\n        let len = max(length(d), FA2_DIST_FLOOR);\n        let mag = select(w, w * log(1.0 + len) / len, LINLOG); // linear: |F| = w len; linlog: |F| = w log(1 + len)\n        f = f + d * mag;\n    }\n    if (DISTRIBUTED) { f = f / pi.w; }\n    store_force(i, f);                                         // overwrites: attraction is the first writer of force each iteration\n}";
+export declare const fa2AttractionWgsl = "fn store_force(i: u32, f: vec3f) {\n    force[3u * i] = f.x;\n    force[3u * i + 1u] = f.y;\n    force[3u * i + 2u] = f.z;\n}\n\n@compute @workgroup_size(WG)\nfn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let row = linear_id(wid, lid.x) + P.tierStart;\n    if (row >= P.tierEnd) { return; }                          // no barrier follows in this tier (3.5 rule 1)\n    let i = select(row, perm[row], USE_PERM);\n    let pi = pos[i];                                           // xyz + mass in one load (D23)\n    var f = vec3f(0.0);\n    for (var a = rowPtr[i]; a < rowPtr[i + 1u]; a = a + 1u) {\n        let j = colIdx[a];\n        if (j == i) { continue; }                              // a self-loop exerts no force\n        var w = 1.0;\n        if (HAS_WEIGHTS) { w = weights[a]; }\n        let d = pos[j].xyz - pi.xyz;                           // toward j\n        let len = max(length(d), FA2_DIST_FLOOR);\n        if (LAW == 1u) { w = length(d) / P.frK; }              // LAW 1 (FR, 7.20): |F| = d^2 / k along d / d, unfloored; the linear select below applies w as is\n        if (LAW == 2u) { w = P.springCoefficient * (len - P.springLength) / len; }   // LAW 2 (spring, ngraph generateCreateSpringForce.js:33-36): Hooke k_s (d - L) toward j\n        let mag = select(w, w * log(1.0 + len) / len, LINLOG); // linear: |F| = w len; linlog: |F| = w log(1 + len)\n        f = f + d * mag;\n    }\n    if (DISTRIBUTED) { f = f / pi.w; }\n    store_force(i, f);                                         // overwrites: attraction is the first writer of force each iteration\n}";
 //# sourceMappingURL=fa2-attraction.wgsl.d.ts.map

package/dist/src/wgsl/fa2-attraction.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-attraction.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-attraction.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,yHAAyH;AACzH,eAAO,MAAM,iBAAiB,wxCAyB5B,CAAC"}
+{"version":3,"file":"fa2-attraction.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-attraction.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,yHAAyH;AACzH,eAAO,MAAM,iBAAiB,0mDA2B5B,CAAC"}

package/dist/src/wgsl/fa2-attraction.wgsl.js

@@ -3,7 +3,10 @@
  * attraction force over the undirected CSR rows (both arcs present, so the sum is symmetric with no atomics), the
  * linear or linlog law, the optional weights, the distributed-action division by the mass in `pos.w`, written as
  * the FIRST writer of `force` each iteration. P3 ships the thread-per-row tier over `[tierStart, tierEnd)` = `[0, n)`
- * with `USE_PERM = false`; the subgroup / workgroup tiers arrive with P4 (`TIER`).
+ * with `USE_PERM = false`; the subgroup / workgroup tiers arrive with P4 (`TIER`). `LAW` (P5, spec 7.20) picks the
+ * pair law: 0 = the FA2 text, 1 = Fruchterman-Reingold `d^2 / k` (unfloored), 2 = ngraph's Hooke spring
+ * `k_s (d - L)`; under 1 / 2 the models compile `LINLOG = false` and `HAS_WEIGHTS = false`, and the law overwrites
+ * `w` so weights are ignored either way.
  *
  * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5) are textual edits of it.
  */
@@ -28,6 +31,8 @@ fn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_i
         if (HAS_WEIGHTS) { w = weights[a]; }
         let d = pos[j].xyz - pi.xyz;                           // toward j
         let len = max(length(d), FA2_DIST_FLOOR);
+        if (LAW == 1u) { w = length(d) / P.frK; }              // LAW 1 (FR, 7.20): |F| = d^2 / k along d / d, unfloored; the linear select below applies w as is
+        if (LAW == 2u) { w = P.springCoefficient * (len - P.springLength) / len; }   // LAW 2 (spring, ngraph generateCreateSpringForce.js:33-36): Hooke k_s (d - L) toward j
         let mag = select(w, w * log(1.0 + len) / len, LINLOG); // linear: |F| = w len; linlog: |F| = w log(1 + len)
         f = f + d * mag;
     }

package/dist/src/wgsl/fa2-attraction.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-attraction.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-attraction.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,yHAAyH;AACzH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;EAyB1C,CAAC"}
+{"version":3,"file":"fa2-attraction.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-attraction.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,yHAAyH;AACzH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B1C,CAAC"}

package/dist/src/wgsl/fa2-integrate.wgsl.d.ts

@@ -4,10 +4,15 @@
  * networkx mode `m |F|`, contract 4.6), the position update with no displacement clamp (D25), z never integrated
  * in 2D (spec 7.13), `oldForce` stored in paper mode for fixed nodes too (spec 7.11), and the partials A
  * (sum p, sum |p - c|^2, min, max with max |p - c|^2 in `max.w`) and C (sum |dp| over free rows, free count) in
- * uniform control flow.
+ * uniform control flow. `APPLY` (P5, spec 7.20) picks the integrator: 0 = the FA2 text, 1 = the Fruchterman-Reingold
+ * temperature cap `min(|F|, t)` along F, 2 = ngraph's semi-implicit Euler step with drag and the unit speed clamp
+ * over the velocity that lives in the `oldForce` slot (PD-2), which also folds the free kinetic energy into
+ * `partials.swingTraction.x` (PD-4); mode 1 folds the free force energy `sum |F|^2` into the same slot for K1's
+ * adaptive cooling and takes its temperature from the state block when `FA2_FLAG_ADAPTIVE` is set. The energy
+ * reduction runs under every mode; only its write is conditional.
  *
  * Body only (spec 3.5, D9); normative text (contract 4.5); the K5 sabotage mutations (P3-T5) are textual edits of it.
  */
 /** The K5 body: entry point `integrate`; calls the reduction helpers (`needs: ["subgroups"]`, contract 4.3). */
-export declare const fa2IntegrateWgsl = "fn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }\nfn load_old(i: u32) -> vec3f { return vec3f(oldForce[3u * i], oldForce[3u * i + 1u], oldForce[3u * i + 2u]); }\nfn store_old(i: u32, f: vec3f) {\n    oldForce[3u * i] = f.x;\n    oldForce[3u * i + 1u] = f.y;\n    oldForce[3u * i + 2u] = f.z;\n}\n\n@compute @workgroup_size(WG)\nfn integrate(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    var dp = vec3f(0.0);\n    var p = vec4f(0.0);\n    var free = false;\n    var valid = false;\n    if (i < P.n) {\n        valid = true;\n        let f = load_force(i);\n        p = pos[i];\n        var swing_i = p.w * length(f);                                     // SWING_MODE 1: NetworkX's local swinging m |F| (layout.py line 1497)\n        if (SWING_MODE == 0u) { swing_i = p.w * length(f - load_old(i)); }  // paper: m |F(t) - F(t-1)|, recomputed inline (7.2)\n        let factor = S.speed / (1.0 + sqrt(S.speed * swing_i));\n        let fixed = mask_bit(fixedMask[i >> 5u], i);\n        dp = select(f * factor, vec3f(0.0), fixed);                        // no clamp on dp (D25)\n        if (P.dim == 2u) { dp.z = 0.0; }                                   // 2D never integrates z (7.13)\n        p = vec4f(p.xyz + dp, p.w);\n        pos[i] = p;\n        if (SWING_MODE == 0u) { store_old(i, f); }                         // fixed nodes too, so a later unpin sees no stale swing (7.11)\n        free = !fixed;\n    }\n    // uniform control flow from here (3.5 rule 1): partials A (sum p, sum |p - c|^2, min, max over valid rows) and C (sum |dp|, free count)\n    let c = S.centroid.xyz;\n    var sumv = vec4f(0.0);\n    var lo = vec4f(F32_MAX);\n    var hi = vec4f(-F32_MAX);\n    var dl = 0.0;\n    var fr = 0u;\n    if (valid) {\n        let q = p.xyz - c;\n        sumv = vec4f(p.xyz, dot(q, q));\n        lo = vec4f(p.xyz, 0.0);\n        hi = vec4f(p.xyz, dot(q, q));                                  // max.w carries max |p - c|^2 so K1 can write the exact layoutRadius (spec 3.3)\n    }\n    if (free) { dl = length(dp); fr = 1u; }\n    let tSum = wg_reduce_vec4(sumv, lid.x, 0u);\n    let tLo = wg_reduce_vec4(lo, lid.x, 1u);\n    let tHi = wg_reduce_vec4(hi, lid.x, 2u);\n    let tDl = wg_reduce_f32(dl, lid.x, 0u);\n    let tFr = wg_reduce_u32(fr, lid.x, 0u);\n    if (lid.x == 0u) {\n        let g = group_id(wid);\n        partials[g].sum = tSum;\n        partials[g].min = tLo;\n        partials[g].max = tHi;\n        partials[g].dispFree = vec2f(tDl, f32(tFr));\n    }\n}";
+export declare const fa2IntegrateWgsl = "fn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }\nfn load_old(i: u32) -> vec3f { return vec3f(oldForce[3u * i], oldForce[3u * i + 1u], oldForce[3u * i + 2u]); }\nfn store_old(i: u32, f: vec3f) {\n    oldForce[3u * i] = f.x;\n    oldForce[3u * i + 1u] = f.y;\n    oldForce[3u * i + 2u] = f.z;\n}\n\n@compute @workgroup_size(WG)\nfn integrate(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    var dp = vec3f(0.0);\n    var p = vec4f(0.0);\n    var free = false;\n    var valid = false;\n    var ke = 0.0;\n    if (i < P.n) {\n        valid = true;\n        let f = load_force(i);\n        p = pos[i];\n        var swing_i = p.w * length(f);                                     // SWING_MODE 1: NetworkX's local swinging m |F| (layout.py line 1497)\n        if (SWING_MODE == 0u) { swing_i = p.w * length(f - load_old(i)); }  // paper: m |F(t) - F(t-1)|, recomputed inline (7.2)\n        let factor = S.speed / (1.0 + sqrt(S.speed * swing_i));\n        let fixed = mask_bit(fixedMask[i >> 5u], i);\n        dp = select(f * factor, vec3f(0.0), fixed);                        // APPLY 0 (FA2): no clamp on dp (D25)\n        if (APPLY == 1u) {                                                  // APPLY 1 (FR, 7.20): move along F by min(|F|, t); a fixed node stays\n            let mag = length(f);\n            let t = select(P.temperature, S.temperature, (P.flags & FA2_FLAG_ADAPTIVE) != 0u);   // adaptive cooling: K1's state temperature\n            dp = vec3f(0.0);\n            if (mag > 0.0 && !fixed) { dp = f * (min(mag, t) / mag); }\n            ke = select(0.0, dot(f, f), !fixed);                              // the force energy of Hu's step control, folded like the spring preset's kinetic energy\n        }\n        if (APPLY == 2u) {                                                  // APPLY 2 (spring-electrical): ngraph's Euler step over the velocity in the oldForce slot (PD-2)\n            var v = load_old(i);\n            let fd = f - P.dragCoefficient * v;                             // drag (generateCreateDragForce.js:18)\n            v = v + (P.timeStep / p.w) * fd;                                 // v += (dt / m) F (generateIntegrator.js:27-29)\n            let sp = length(v);\n            if (sp > 1.0) { v = v / sp; }                                     // the unit speed clamp (generateIntegrator.js:33-37)\n            if (P.dim == 2u) { v.z = 0.0; }\n            dp = select(P.timeStep * v, vec3f(0.0), fixed);                  // dp = dt v; a pinned body is skipped (generateIntegrator.js:21, 39-41)\n            if (!fixed) { store_old(i, v); }\n            ke = select(0.0, 0.5 * p.w * dot(v, v), !fixed);                 // partials B under APPLY 2 (PD-4)\n        }\n        if (P.dim == 2u) { dp.z = 0.0; }                                   // 2D never integrates z (7.13)\n        p = vec4f(p.xyz + dp, p.w);\n        pos[i] = p;\n        if (SWING_MODE == 0u) { store_old(i, f); }                         // fixed nodes too, so a later unpin sees no stale swing (7.11)\n        free = !fixed;\n    }\n    // uniform control flow from here (3.5 rule 1): partials A (sum p, sum |p - c|^2, min, max over valid rows) and C (sum |dp|, free count)\n    let c = S.centroid.xyz;\n    var sumv = vec4f(0.0);\n    var lo = vec4f(F32_MAX);\n    var hi = vec4f(-F32_MAX);\n    var dl = 0.0;\n    var fr = 0u;\n    if (valid) {\n        let q = p.xyz - c;\n        sumv = vec4f(p.xyz, dot(q, q));\n        lo = vec4f(p.xyz, 0.0);\n        hi = vec4f(p.xyz, dot(q, q));                                  // max.w carries max |p - c|^2 so K1 can write the exact layoutRadius (spec 3.3)\n    }\n    if (free) { dl = length(dp); fr = 1u; }\n    let tSum = wg_reduce_vec4(sumv, lid.x, 0u);\n    let tLo = wg_reduce_vec4(lo, lid.x, 1u);\n    let tHi = wg_reduce_vec4(hi, lid.x, 2u);\n    let tDl = wg_reduce_f32(dl, lid.x, 0u);\n    let tFr = wg_reduce_u32(fr, lid.x, 0u);\n    let tKe = wg_reduce_f32(ke, lid.x, 0u);\n    if (lid.x == 0u) {\n        let g = group_id(wid);\n        partials[g].sum = tSum;\n        partials[g].min = tLo;\n        partials[g].max = tHi;\n        partials[g].dispFree = vec2f(tDl, f32(tFr));\n        if (APPLY != 0u) { partials[g].swingTraction = vec2f(tKe, 0.0); }   // overwrites K3's epilogue: K4 never runs under FR or the preset (PD-4)\n    }\n}";
 //# sourceMappingURL=fa2-integrate.wgsl.d.ts.map

package/dist/src/wgsl/fa2-integrate.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-integrate.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-integrate.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,gHAAgH;AAChH,eAAO,MAAM,gBAAgB,4jFAwD3B,CAAC"}
+{"version":3,"file":"fa2-integrate.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-integrate.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,gHAAgH;AAChH,eAAO,MAAM,gBAAgB,u1IA6E3B,CAAC"}

package/dist/src/wgsl/fa2-integrate.wgsl.js

@@ -4,7 +4,12 @@
  * networkx mode `m |F|`, contract 4.6), the position update with no displacement clamp (D25), z never integrated
  * in 2D (spec 7.13), `oldForce` stored in paper mode for fixed nodes too (spec 7.11), and the partials A
  * (sum p, sum |p - c|^2, min, max with max |p - c|^2 in `max.w`) and C (sum |dp| over free rows, free count) in
- * uniform control flow.
+ * uniform control flow. `APPLY` (P5, spec 7.20) picks the integrator: 0 = the FA2 text, 1 = the Fruchterman-Reingold
+ * temperature cap `min(|F|, t)` along F, 2 = ngraph's semi-implicit Euler step with drag and the unit speed clamp
+ * over the velocity that lives in the `oldForce` slot (PD-2), which also folds the free kinetic energy into
+ * `partials.swingTraction.x` (PD-4); mode 1 folds the free force energy `sum |F|^2` into the same slot for K1's
+ * adaptive cooling and takes its temperature from the state block when `FA2_FLAG_ADAPTIVE` is set. The energy
+ * reduction runs under every mode; only its write is conditional.
  *
  * Body only (spec 3.5, D9); normative text (contract 4.5); the K5 sabotage mutations (P3-T5) are textual edits of it.
  */
@@ -24,6 +29,7 @@ fn integrate(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id
     var p = vec4f(0.0);
     var free = false;
     var valid = false;
+    var ke = 0.0;
     if (i < P.n) {
         valid = true;
         let f = load_force(i);
@@ -32,7 +38,25 @@ fn integrate(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id
         if (SWING_MODE == 0u) { swing_i = p.w * length(f - load_old(i)); }  // paper: m |F(t) - F(t-1)|, recomputed inline (7.2)
         let factor = S.speed / (1.0 + sqrt(S.speed * swing_i));
         let fixed = mask_bit(fixedMask[i >> 5u], i);
-        dp = select(f * factor, vec3f(0.0), fixed);                        // no clamp on dp (D25)
+        dp = select(f * factor, vec3f(0.0), fixed);                        // APPLY 0 (FA2): no clamp on dp (D25)
+        if (APPLY == 1u) {                                                  // APPLY 1 (FR, 7.20): move along F by min(|F|, t); a fixed node stays
+            let mag = length(f);
+            let t = select(P.temperature, S.temperature, (P.flags & FA2_FLAG_ADAPTIVE) != 0u);   // adaptive cooling: K1's state temperature
+            dp = vec3f(0.0);
+            if (mag > 0.0 && !fixed) { dp = f * (min(mag, t) / mag); }
+            ke = select(0.0, dot(f, f), !fixed);                              // the force energy of Hu's step control, folded like the spring preset's kinetic energy
+        }
+        if (APPLY == 2u) {                                                  // APPLY 2 (spring-electrical): ngraph's Euler step over the velocity in the oldForce slot (PD-2)
+            var v = load_old(i);
+            let fd = f - P.dragCoefficient * v;                             // drag (generateCreateDragForce.js:18)
+            v = v + (P.timeStep / p.w) * fd;                                 // v += (dt / m) F (generateIntegrator.js:27-29)
+            let sp = length(v);
+            if (sp > 1.0) { v = v / sp; }                                     // the unit speed clamp (generateIntegrator.js:33-37)
+            if (P.dim == 2u) { v.z = 0.0; }
+            dp = select(P.timeStep * v, vec3f(0.0), fixed);                  // dp = dt v; a pinned body is skipped (generateIntegrator.js:21, 39-41)
+            if (!fixed) { store_old(i, v); }
+            ke = select(0.0, 0.5 * p.w * dot(v, v), !fixed);                 // partials B under APPLY 2 (PD-4)
+        }
         if (P.dim == 2u) { dp.z = 0.0; }                                   // 2D never integrates z (7.13)
         p = vec4f(p.xyz + dp, p.w);
         pos[i] = p;
@@ -58,12 +82,14 @@ fn integrate(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id
     let tHi = wg_reduce_vec4(hi, lid.x, 2u);
     let tDl = wg_reduce_f32(dl, lid.x, 0u);
     let tFr = wg_reduce_u32(fr, lid.x, 0u);
+    let tKe = wg_reduce_f32(ke, lid.x, 0u);
     if (lid.x == 0u) {
         let g = group_id(wid);
         partials[g].sum = tSum;
         partials[g].min = tLo;
         partials[g].max = tHi;
         partials[g].dispFree = vec2f(tDl, f32(tFr));
+        if (APPLY != 0u) { partials[g].swingTraction = vec2f(tKe, 0.0); }   // overwrites K3's epilogue: K4 never runs under FR or the preset (PD-4)
     }
 }`;
 //# sourceMappingURL=fa2-integrate.wgsl.js.map

package/dist/src/wgsl/fa2-integrate.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-integrate.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-integrate.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,gHAAgH;AAChH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwDzC,CAAC"}
+{"version":3,"file":"fa2-integrate.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-integrate.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,gHAAgH;AAChH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6EzC,CAAC"}

package/dist/src/wgsl/fa2-repulsion-exact.wgsl.d.ts

@@ -1,6 +1,8 @@
 /**
  * The `fa2-repulsion-exact` kernel body (K3; contract 4.5; spec 7.6, 7.9, 7.10): the tiled all-pairs repulsion
- * `|F| = k m_i m_j / d` with the 0.01 distance floor and the antisymmetric coincident kick, the gravity epilogue
+ * `|F| = k m_i m_j / d` with the 0.01 distance floor and the antisymmetric coincident kick (`LAW` 0; P5's `LAW` 1
+ * is Fruchterman-Reingold `k^2 / d` and `LAW` 2 ngraph's Coulomb `-g m_i m_j / d^2`, both unfloored, spec 7.20,
+ * with the kick's magnitude taken from the law at d = 0.01, PD-10), the gravity epilogue
  * (GRAVITY_CENTER 0 = centroid, 1 = origin; STRONG_GRAVITY) added under the `valid` guard, `force += f`, and the
  * swing / traction workgroup reduction in uniform control flow (SWING_MODE 0 = paper: free nodes only against
  * `oldForce`; 1 = NetworkX: positions and forces mixed, every node) whose lane 0 writes
@@ -8,5 +10,5 @@
  * `array<f32>` read through the per-body helpers (4.4 rule 6). Normative text, copied verbatim: the P1-T5 sabotage
  * rows (gravity sign, `k / d2`, the `jj != i` guard, the `.w` mass lane) are textual edits of this string.
  */
-export declare const fa2RepulsionExactWgsl = "\nvar<workgroup> tile: array<vec4f, WG>;                         // xyz + mass, 4 KiB at WG = 256\n\nfn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }\nfn store_force(i: u32, f: vec3f) {\n    force[3u * i] = f.x;\n    force[3u * i + 1u] = f.y;\n    force[3u * i + 2u] = f.z;\n}\nfn load_old(i: u32) -> vec3f { return vec3f(oldForce[3u * i], oldForce[3u * i + 1u], oldForce[3u * i + 2u]); }\nfn gravity_force(pi: vec4f) -> vec3f {                         // spec 7.9: centroid (GRAVITY_CENTER 0) or origin (1); regular or strong\n    var q = pi.xyz;\n    if (GRAVITY_CENTER == 0u) { q = pi.xyz - S.centroid.xyz; }\n    if (STRONG_GRAVITY) { return -P.gravity * pi.w * q; }\n    let d = length(q);\n    if (d > FA2_DIST_FLOOR) { return -P.gravity * pi.w * q / d; }\n    return vec3f(0.0);\n}\n\n@compute @workgroup_size(WG)\nfn repulsion(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    let valid = i < P.n;\n    var pi = vec4f(0.0);\n    if (valid) { pi = pos[i]; }\n    var f = vec3f(0.0);\n    let tiles = (P.n + WG - 1u) / WG;\n    for (var t = 0u; t < tiles; t = t + 1u) {\n        let j = t * WG + lid.x;\n        if (j < P.n) { tile[lid.x] = pos[j]; } else { tile[lid.x] = vec4f(0.0); }   // guarded fill; mass 0 marks the pad\n        workgroupBarrier();                                                       // uniform: every invocation reaches it\n        for (var s = 0u; s < WG; s = s + 1u) {\n            let o = tile[s];\n            let jj = t * WG + s;\n            if (o.w > 0.0 && jj != i) {                                           // mass > 0 for every real node, 0 for the pad\n                let d = pi.xyz - o.xyz;\n                var d2 = dot(d, d);\n                if (d2 < FA2_COINCIDENT_SQ) {                                     // coincident: antisymmetric unit kick of magnitude k m_i m_j / 0.01 (7.2)\n                    f = f + kick_dir(i, jj, P.dim) * (P.scalingRatio * pi.w * o.w / FA2_DIST_FLOOR);\n                    continue;\n                }\n                d2 = max(d2, FA2_DIST_FLOOR_SQ);                                  // d >= 0.01\n                let k = P.scalingRatio * pi.w * o.w;\n                f = f + d * (k / d2);                                             // |F| = k m_i m_j / d along d / d\n            }\n        }\n        workgroupBarrier();\n    }\n    // epilogue (7.9, 7.10): gravity and force += under the guard, the swing / traction reduction outside it\n    var sw = 0.0;\n    var tr = 0.0;\n    if (valid) {\n        f = f + gravity_force(pi);\n        let fnew = load_force(i) + f;\n        store_force(i, fnew);\n        if (SWING_MODE == 1u) {                                                   // NetworkX: positions and forces mixed, every node (7.2)\n            sw = pi.w * length(pi.xyz - fnew);\n            tr = 0.5 * pi.w * length(pi.xyz + fnew);\n        } else if (!mask_bit(fixedMask[i >> 5u], i)) {                            // paper: free nodes only (Gephi ForceAtlas2.java 283-293)\n            let fold = load_old(i);\n            sw = pi.w * length(fnew - fold);\n            tr = 0.5 * pi.w * length(fnew + fold);\n        }\n    }\n    let t = wg_reduce_vec4(vec4f(sw, tr, 0.0, 0.0), lid.x, 0u);                   // uniform control flow: 256 -> 1\n    if (lid.x == 0u) { partials[group_id(wid)].swingTraction = t.xy; }\n}\n";
+export declare const fa2RepulsionExactWgsl = "\nvar<workgroup> tile: array<vec4f, WG>;                         // xyz + mass, 4 KiB at WG = 256\n\nfn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }\nfn store_force(i: u32, f: vec3f) {\n    force[3u * i] = f.x;\n    force[3u * i + 1u] = f.y;\n    force[3u * i + 2u] = f.z;\n}\nfn load_old(i: u32) -> vec3f { return vec3f(oldForce[3u * i], oldForce[3u * i + 1u], oldForce[3u * i + 2u]); }\nfn kick_magnitude(mi: f32, mj: f32) -> f32 {                   // the law's magnitude at d = FA2_DIST_FLOOR (PD-10)\n    if (LAW == 1u) { return P.frK * P.frK / FA2_DIST_FLOOR; }\n    if (LAW == 2u) { return -P.coulomb * mi * mj / FA2_DIST_FLOOR_SQ; }\n    return P.scalingRatio * mi * mj / FA2_DIST_FLOOR;\n}\nfn gravity_force(pi: vec4f) -> vec3f {                         // spec 7.9: centroid (GRAVITY_CENTER 0) or origin (1); regular or strong\n    var q = pi.xyz;\n    if (GRAVITY_CENTER == 0u) { q = pi.xyz - S.centroid.xyz; }\n    if (STRONG_GRAVITY) { return -P.gravity * pi.w * q; }\n    let d = length(q);\n    if (d > FA2_DIST_FLOOR) { return -P.gravity * pi.w * q / d; }\n    return vec3f(0.0);\n}\n\n@compute @workgroup_size(WG)\nfn repulsion(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    let valid = i < P.n;\n    var pi = vec4f(0.0);\n    if (valid) { pi = pos[i]; }\n    var f = vec3f(0.0);\n    let tiles = (P.n + WG - 1u) / WG;\n    for (var t = 0u; t < tiles; t = t + 1u) {\n        let j = t * WG + lid.x;\n        if (j < P.n) { tile[lid.x] = pos[j]; } else { tile[lid.x] = vec4f(0.0); }   // guarded fill; mass 0 marks the pad\n        workgroupBarrier();                                                       // uniform: every invocation reaches it\n        for (var s = 0u; s < WG; s = s + 1u) {\n            let o = tile[s];\n            let jj = t * WG + s;\n            if (o.w > 0.0 && jj != i) {                                           // mass > 0 for every real node, 0 for the pad\n                let d = pi.xyz - o.xyz;\n                var d2 = dot(d, d);\n                if (d2 < FA2_COINCIDENT_SQ) {                                     // coincident: antisymmetric unit kick of the law's magnitude at d = 0.01 (7.2; PD-10)\n                    f = f + kick_dir(i, jj, P.dim) * kick_magnitude(pi.w, o.w);\n                    continue;\n                }\n                if (LAW == 0u) { d2 = max(d2, FA2_DIST_FLOOR_SQ); }               // FA2 alone floors d >= 0.01 (7.2); FR and coulomb are unfloored (7.20)\n                let k = P.scalingRatio * pi.w * o.w;\n                if (LAW == 0u) { f = f + d * (k / d2); }                          // LAW 0 (FA2): |F| = k m_i m_j / d along d / d\n                if (LAW == 1u) { f = f + d * (P.frK * P.frK / d2); }              // LAW 1 (FR, 7.20): |F| = k^2 / d, mass ignored\n                if (LAW == 2u) { f = f + d * (-P.coulomb * pi.w * o.w / (d2 * sqrt(d2))); }   // LAW 2 (coulomb, ngraph generateQuadTree.js:131-132): |F| = -g m_i m_j / d^2\n            }\n        }\n        workgroupBarrier();\n    }\n    // epilogue (7.9, 7.10): gravity and force += under the guard, the swing / traction reduction outside it\n    var sw = 0.0;\n    var tr = 0.0;\n    if (valid) {\n        f = f + gravity_force(pi);\n        let fnew = load_force(i) + f;\n        store_force(i, fnew);\n        if (SWING_MODE == 1u) {                                                   // NetworkX: positions and forces mixed, every node (7.2)\n            sw = pi.w * length(pi.xyz - fnew);\n            tr = 0.5 * pi.w * length(pi.xyz + fnew);\n        } else if (!mask_bit(fixedMask[i >> 5u], i)) {                            // paper: free nodes only (Gephi ForceAtlas2.java 283-293)\n            let fold = load_old(i);\n            sw = pi.w * length(fnew - fold);\n            tr = 0.5 * pi.w * length(fnew + fold);\n        }\n    }\n    let t = wg_reduce_vec4(vec4f(sw, tr, 0.0, 0.0), lid.x, 0u);                   // uniform control flow: 256 -> 1\n    if (lid.x == 0u) { partials[group_id(wid)].swingTraction = t.xy; }\n}\n";
 //# sourceMappingURL=fa2-repulsion-exact.wgsl.d.ts.map

package/dist/src/wgsl/fa2-repulsion-exact.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-repulsion-exact.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-repulsion-exact.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,g4GAmEjC,CAAC"}
+{"version":3,"file":"fa2-repulsion-exact.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-repulsion-exact.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,yiIA0EjC,CAAC"}

package/dist/src/wgsl/fa2-repulsion-exact.wgsl.js

@@ -1,6 +1,8 @@
 /**
  * The `fa2-repulsion-exact` kernel body (K3; contract 4.5; spec 7.6, 7.9, 7.10): the tiled all-pairs repulsion
- * `|F| = k m_i m_j / d` with the 0.01 distance floor and the antisymmetric coincident kick, the gravity epilogue
+ * `|F| = k m_i m_j / d` with the 0.01 distance floor and the antisymmetric coincident kick (`LAW` 0; P5's `LAW` 1
+ * is Fruchterman-Reingold `k^2 / d` and `LAW` 2 ngraph's Coulomb `-g m_i m_j / d^2`, both unfloored, spec 7.20,
+ * with the kick's magnitude taken from the law at d = 0.01, PD-10), the gravity epilogue
  * (GRAVITY_CENTER 0 = centroid, 1 = origin; STRONG_GRAVITY) added under the `valid` guard, `force += f`, and the
  * swing / traction workgroup reduction in uniform control flow (SWING_MODE 0 = paper: free nodes only against
  * `oldForce`; 1 = NetworkX: positions and forces mixed, every node) whose lane 0 writes
@@ -18,6 +20,11 @@ fn store_force(i: u32, f: vec3f) {
     force[3u * i + 2u] = f.z;
 }
 fn load_old(i: u32) -> vec3f { return vec3f(oldForce[3u * i], oldForce[3u * i + 1u], oldForce[3u * i + 2u]); }
+fn kick_magnitude(mi: f32, mj: f32) -> f32 {                   // the law's magnitude at d = FA2_DIST_FLOOR (PD-10)
+    if (LAW == 1u) { return P.frK * P.frK / FA2_DIST_FLOOR; }
+    if (LAW == 2u) { return -P.coulomb * mi * mj / FA2_DIST_FLOOR_SQ; }
+    return P.scalingRatio * mi * mj / FA2_DIST_FLOOR;
+}
 fn gravity_force(pi: vec4f) -> vec3f {                         // spec 7.9: centroid (GRAVITY_CENTER 0) or origin (1); regular or strong
     var q = pi.xyz;
     if (GRAVITY_CENTER == 0u) { q = pi.xyz - S.centroid.xyz; }
@@ -45,13 +52,15 @@ fn repulsion(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id
             if (o.w > 0.0 && jj != i) {                                           // mass > 0 for every real node, 0 for the pad
                 let d = pi.xyz - o.xyz;
                 var d2 = dot(d, d);
-                if (d2 < FA2_COINCIDENT_SQ) {                                     // coincident: antisymmetric unit kick of magnitude k m_i m_j / 0.01 (7.2)
-                    f = f + kick_dir(i, jj, P.dim) * (P.scalingRatio * pi.w * o.w / FA2_DIST_FLOOR);
+                if (d2 < FA2_COINCIDENT_SQ) {                                     // coincident: antisymmetric unit kick of the law's magnitude at d = 0.01 (7.2; PD-10)
+                    f = f + kick_dir(i, jj, P.dim) * kick_magnitude(pi.w, o.w);
                     continue;
                 }
-                d2 = max(d2, FA2_DIST_FLOOR_SQ);                                  // d >= 0.01
+                if (LAW == 0u) { d2 = max(d2, FA2_DIST_FLOOR_SQ); }               // FA2 alone floors d >= 0.01 (7.2); FR and coulomb are unfloored (7.20)
                 let k = P.scalingRatio * pi.w * o.w;
-                f = f + d * (k / d2);                                             // |F| = k m_i m_j / d along d / d
+                if (LAW == 0u) { f = f + d * (k / d2); }                          // LAW 0 (FA2): |F| = k m_i m_j / d along d / d
+                if (LAW == 1u) { f = f + d * (P.frK * P.frK / d2); }              // LAW 1 (FR, 7.20): |F| = k^2 / d, mass ignored
+                if (LAW == 2u) { f = f + d * (-P.coulomb * pi.w * o.w / (d2 * sqrt(d2))); }   // LAW 2 (coulomb, ngraph generateQuadTree.js:131-132): |F| = -g m_i m_j / d^2
             }
         }
         workgroupBarrier();

package/dist/src/wgsl/fa2-repulsion-exact.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-repulsion-exact.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-repulsion-exact.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmE/C,CAAC"}
+{"version":3,"file":"fa2-repulsion-exact.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-repulsion-exact.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0E/C,CAAC"}

package/dist/src/wgsl/fa2-stats-finalize.wgsl.d.ts

@@ -4,11 +4,18 @@
  * exact spec 3.3 value from `partials.max.w`), bounding box, mean displacement over free nodes (0 when every node
  * is fixed), the settle counter -- increments the iteration counter and writes the K1 half of the trace record.
  * On the first iteration after load() (`FA2_FLAG_FIRST`) it folds nothing and keeps the host-written state.
+ * `STATS_MODE` (P5, spec 7.20) adds the model statistic: 0 = the FA2 text, 1 = the Fruchterman-Reingold temperature
+ * of this iteration into `S.temperature` and the trace's `modelScalar` -- the uniform's under the linear schedule,
+ * or, with `FA2_FLAG_ADAPTIVE` set, the adaptive one: the previous iteration's force energy (K5 folds sum |F|^2 over
+ * free nodes into `partials.swingTraction.x`) against `S.frEnergy` grows the temperature by 1 / FR_COOLING_STEP after
+ * FR_COOLING_PATIENCE consecutive falls and shrinks it by FR_COOLING_STEP on a rise (Yifan Hu 2005, section 3.2);
+ * 2 = the spring-electrical kinetic energy K5 folded into `partials.swingTraction.x` (PD-4) into `S.kineticEnergy`
+ * and the trace.
  *
  * This file holds the kernel BODY only (spec 3.5, D9): no bind-group lines and no `override` lines -- the composer
  * emits them from the registry entry in src/kernels.ts (contract 3.10.1). The text is normative (contract 4.5) and
  * is the target of the K1 sabotage mutations (test/helpers/sabotage.ts, P3-T5); amend the contract before editing.
  */
 /** The K1 body: entry point `stats_finalize`; calls the reduction helpers (`needs: ["subgroups"]`, contract 4.3). */
-export declare const fa2StatsFinalizeWgsl = "// K1: folds the previous integrate's partials into the state block (spec 7.4); one workgroup\n@compute @workgroup_size(WG)\nfn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {\n    let groups = (P.n + WG - 1u) / WG;\n    let fold = (P.flags & FA2_FLAG_FIRST) == 0u;    // the first iteration after load() keeps the host-written state\n    var sum = vec4f(0.0);\n    var lo = vec4f(F32_MAX);\n    var hi = vec4f(-F32_MAX);\n    var disp = 0.0;\n    var free = 0u;\n    if (fold) {\n        for (var g = lid.x; g < groups; g = g + WG) {   // sequential per lane in index order: deterministic\n            let q = partials[g];\n            sum = sum + q.sum;\n            lo = min(lo, q.min);\n            hi = max(hi, q.max);\n            disp = disp + q.dispFree.x;\n            free = free + u32(q.dispFree.y);\n        }\n    }\n    let tSum = wg_reduce_vec4(sum, lid.x, 0u);\n    let tLo = wg_reduce_vec4(lo, lid.x, 1u);\n    let tHi = wg_reduce_vec4(hi, lid.x, 2u);\n    let tDisp = wg_reduce_f32(disp, lid.x, 0u);\n    let tFree = wg_reduce_u32(free, lid.x, 0u);\n    if (lid.x == 0u) {\n        if (fold) {\n            let n = f32(P.n);\n            let c = tSum.xyz / n;\n            S.centroid = vec4f(c, 0.0);\n            S.rmsRadius = sqrt(max(tSum.w, 0.0) / n);                  // RMS radius about the previous centroid (7.17)\n            S.min = vec4f(tLo.xyz, 0.0);\n            S.max = vec4f(tHi.xyz, 0.0);\n            S.radius = sqrt(max(tHi.w, 0.0));                          // max |p - centroid| about the same previous centroid as rmsRadius (K5 puts |q|^2 in max.w)\n            let meanDisp = select(tDisp / f32(tFree), 0.0, tFree == 0u);  // all-fixed: 0, never NaN (7.4)\n            S.meanDisplacement = meanDisp;\n            S.settledCount = select(0u, S.settledCount + 1u, meanDisp <= P.settleThreshold * S.rmsRadius);\n        }\n        S.iteration = S.iteration + 1u;\n        T[P.iterationIndex].meanDisplacement = S.meanDisplacement;\n        T[P.iterationIndex].settledCount = S.settledCount;\n        T[P.iterationIndex].iteration = S.iteration;\n    }\n}";
+export declare const fa2StatsFinalizeWgsl = "// K1: folds the previous integrate's partials into the state block (spec 7.4); one workgroup\n@compute @workgroup_size(WG)\nfn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {\n    let groups = (P.n + WG - 1u) / WG;\n    let fold = (P.flags & FA2_FLAG_FIRST) == 0u;    // the first iteration after load() keeps the host-written state\n    var sum = vec4f(0.0);\n    var lo = vec4f(F32_MAX);\n    var hi = vec4f(-F32_MAX);\n    var disp = 0.0;\n    var free = 0u;\n    var ke = 0.0;\n    if (fold) {\n        for (var g = lid.x; g < groups; g = g + WG) {   // sequential per lane in index order: deterministic\n            let q = partials[g];\n            sum = sum + q.sum;\n            lo = min(lo, q.min);\n            hi = max(hi, q.max);\n            disp = disp + q.dispFree.x;\n            free = free + u32(q.dispFree.y);\n            ke = ke + q.swingTraction.x;\n        }\n    }\n    let tSum = wg_reduce_vec4(sum, lid.x, 0u);\n    let tLo = wg_reduce_vec4(lo, lid.x, 1u);\n    let tHi = wg_reduce_vec4(hi, lid.x, 2u);\n    let tDisp = wg_reduce_f32(disp, lid.x, 0u);\n    let tFree = wg_reduce_u32(free, lid.x, 0u);\n    let tKe = wg_reduce_f32(ke, lid.x, 0u);\n    if (lid.x == 0u) {\n        if (fold) {\n            let n = f32(P.n);\n            let c = tSum.xyz / n;\n            S.centroid = vec4f(c, 0.0);\n            S.rmsRadius = sqrt(max(tSum.w, 0.0) / n);                  // RMS radius about the previous centroid (7.17)\n            S.min = vec4f(tLo.xyz, 0.0);\n            S.max = vec4f(tHi.xyz, 0.0);\n            S.radius = sqrt(max(tHi.w, 0.0));                          // max |p - centroid| about the same previous centroid as rmsRadius (K5 puts |q|^2 in max.w)\n            let meanDisp = select(tDisp / f32(tFree), 0.0, tFree == 0u);  // all-fixed: 0, never NaN (7.4)\n            S.meanDisplacement = meanDisp;\n            S.settledCount = select(0u, S.settledCount + 1u, meanDisp <= P.settleThreshold * S.rmsRadius);\n        }\n        S.iteration = S.iteration + 1u;\n        T[P.iterationIndex].meanDisplacement = S.meanDisplacement;\n        T[P.iterationIndex].settledCount = S.settledCount;\n        T[P.iterationIndex].iteration = S.iteration;\n        if (STATS_MODE == 1u) {                                    // FR: this iteration's temperature (7.20) into the state and the trace\n            if ((P.flags & FA2_FLAG_ADAPTIVE) != 0u) {                // adaptive cooling (Yifan Hu 2005 3.2): tKe is the previous iteration's sum |F|^2 over free nodes\n                if (fold) {\n                    var t = S.temperature;\n                    if (tKe < S.frEnergy) {\n                        S.frProgress = S.frProgress + 1u;\n                        if (S.frProgress >= FR_COOLING_PATIENCE) { S.frProgress = 0u; t = t / FR_COOLING_STEP; }\n                    } else {\n                        S.frProgress = 0u;\n                        t = t * FR_COOLING_STEP;\n                    }\n                    S.frEnergy = tKe;\n                    S.temperature = t;\n                }\n            } else {\n                S.temperature = P.temperature;\n            }\n            T[P.iterationIndex].modelScalar = S.temperature;\n        }\n        if (STATS_MODE == 2u) {                                    // spring-electrical: the kinetic energy K5 folded into partials B (PD-4); 0 on the first iteration after load()\n            S.kineticEnergy = tKe;\n            T[P.iterationIndex].modelScalar = tKe;\n        }\n    }\n}";
 //# sourceMappingURL=fa2-stats-finalize.wgsl.d.ts.map

package/dist/src/wgsl/fa2-stats-finalize.wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-stats-finalize.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-stats-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,qHAAqH;AACrH,eAAO,MAAM,oBAAoB,gkEA2C/B,CAAC"}
+{"version":3,"file":"fa2-stats-finalize.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/fa2-stats-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,qHAAqH;AACrH,eAAO,MAAM,oBAAoB,86GAqE/B,CAAC"}

package/dist/src/wgsl/fa2-stats-finalize.wgsl.js

@@ -4,6 +4,13 @@
  * exact spec 3.3 value from `partials.max.w`), bounding box, mean displacement over free nodes (0 when every node
  * is fixed), the settle counter -- increments the iteration counter and writes the K1 half of the trace record.
  * On the first iteration after load() (`FA2_FLAG_FIRST`) it folds nothing and keeps the host-written state.
+ * `STATS_MODE` (P5, spec 7.20) adds the model statistic: 0 = the FA2 text, 1 = the Fruchterman-Reingold temperature
+ * of this iteration into `S.temperature` and the trace's `modelScalar` -- the uniform's under the linear schedule,
+ * or, with `FA2_FLAG_ADAPTIVE` set, the adaptive one: the previous iteration's force energy (K5 folds sum |F|^2 over
+ * free nodes into `partials.swingTraction.x`) against `S.frEnergy` grows the temperature by 1 / FR_COOLING_STEP after
+ * FR_COOLING_PATIENCE consecutive falls and shrinks it by FR_COOLING_STEP on a rise (Yifan Hu 2005, section 3.2);
+ * 2 = the spring-electrical kinetic energy K5 folded into `partials.swingTraction.x` (PD-4) into `S.kineticEnergy`
+ * and the trace.
  *
  * This file holds the kernel BODY only (spec 3.5, D9): no bind-group lines and no `override` lines -- the composer
  * emits them from the registry entry in src/kernels.ts (contract 3.10.1). The text is normative (contract 4.5) and
@@ -20,6 +27,7 @@ fn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
     var hi = vec4f(-F32_MAX);
     var disp = 0.0;
     var free = 0u;
+    var ke = 0.0;
     if (fold) {
         for (var g = lid.x; g < groups; g = g + WG) {   // sequential per lane in index order: deterministic
             let q = partials[g];
@@ -28,6 +36,7 @@ fn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
             hi = max(hi, q.max);
             disp = disp + q.dispFree.x;
             free = free + u32(q.dispFree.y);
+            ke = ke + q.swingTraction.x;
         }
     }
     let tSum = wg_reduce_vec4(sum, lid.x, 0u);
@@ -35,6 +44,7 @@ fn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
     let tHi = wg_reduce_vec4(hi, lid.x, 2u);
     let tDisp = wg_reduce_f32(disp, lid.x, 0u);
     let tFree = wg_reduce_u32(free, lid.x, 0u);
+    let tKe = wg_reduce_f32(ke, lid.x, 0u);
     if (lid.x == 0u) {
         if (fold) {
             let n = f32(P.n);
@@ -52,6 +62,29 @@ fn stats_finalize(@builtin(local_invocation_id) lid: vec3<u32>) {
         T[P.iterationIndex].meanDisplacement = S.meanDisplacement;
         T[P.iterationIndex].settledCount = S.settledCount;
         T[P.iterationIndex].iteration = S.iteration;
+        if (STATS_MODE == 1u) {                                    // FR: this iteration's temperature (7.20) into the state and the trace
+            if ((P.flags & FA2_FLAG_ADAPTIVE) != 0u) {                // adaptive cooling (Yifan Hu 2005 3.2): tKe is the previous iteration's sum |F|^2 over free nodes
+                if (fold) {
+                    var t = S.temperature;
+                    if (tKe < S.frEnergy) {
+                        S.frProgress = S.frProgress + 1u;
+                        if (S.frProgress >= FR_COOLING_PATIENCE) { S.frProgress = 0u; t = t / FR_COOLING_STEP; }
+                    } else {
+                        S.frProgress = 0u;
+                        t = t * FR_COOLING_STEP;
+                    }
+                    S.frEnergy = tKe;
+                    S.temperature = t;
+                }
+            } else {
+                S.temperature = P.temperature;
+            }
+            T[P.iterationIndex].modelScalar = S.temperature;
+        }
+        if (STATS_MODE == 2u) {                                    // spring-electrical: the kinetic energy K5 folded into partials B (PD-4); 0 on the first iteration after load()
+            S.kineticEnergy = tKe;
+            T[P.iterationIndex].modelScalar = tKe;
+        }
     }
 }`;
 //# sourceMappingURL=fa2-stats-finalize.wgsl.js.map

package/dist/src/wgsl/fa2-stats-finalize.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"fa2-stats-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-stats-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,qHAAqH;AACrH,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C7C,CAAC"}
+{"version":3,"file":"fa2-stats-finalize.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/fa2-stats-finalize.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,qHAAqH;AACrH,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqE7C,CAAC"}