@graphty/webgpu-graph-algorithms 0.5.0 → 0.6.0

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

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/types/context.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/types/context.ts"],"names":[],"mappings":"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"}

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

@@ -37,6 +37,38 @@ export interface ForceAtlas2Stats extends LayoutStatsBase {
     readonly speedEfficiency: number;
     readonly trace: ReadonlyArray<ForceAtlas2TraceRecord>;
 }
+/**
+ * One per-iteration trace record of the last completed batch of a Fruchterman-Reingold simulation (spec 3.3
+ * FruchtermanReingoldStats.trace element): K1 writes `temperature` from the iteration's uniform slot (spec 7.20).
+ * @public
+ */
+export interface FruchtermanReingoldTraceRecord {
+    readonly temperature: number;
+    readonly meanDisplacement: number;
+    readonly settledCount: number;
+}
+/** Spec 3.3 FruchtermanReingoldStats, verbatim: the cooling schedule's value replaces the controller fields. */
+export interface FruchtermanReingoldStats extends LayoutStatsBase {
+    readonly temperature: number;
+    readonly trace: ReadonlyArray<FruchtermanReingoldTraceRecord>;
+}
+/**
+ * One per-iteration trace record of the last completed batch of a spring-electrical simulation (spec 3.3
+ * SpringElectricalStats.trace element): `kineticEnergy` is `0.5 * sum m |v|^2` over the free nodes after the
+ * PREVIOUS iteration's integrate: K5 writes it into partials B and the NEXT iteration's K1 folds it (PD-4), so the
+ * first record after load() carries 0 and record i carries the energy of iteration i - 1.
+ * @public
+ */
+export interface SpringElectricalTraceRecord {
+    readonly kineticEnergy: number;
+    readonly meanDisplacement: number;
+    readonly settledCount: number;
+}
+/** Spec 3.3 SpringElectricalStats, verbatim; `kineticEnergy` is the last folded value, one iteration behind the last integrate (PD-4). */
+export interface SpringElectricalStats extends LayoutStatsBase {
+    readonly kineticEnergy: number;
+    readonly trace: ReadonlyArray<SpringElectricalTraceRecord>;
+}
 /** Options of GpuLayoutSimulation.run (spec 3.3). */
 export interface RunOptions {
     readonly maxIter?: number | undefined;
@@ -92,4 +124,24 @@ export interface ResolvedLayoutTuning {
     readonly extentFactor: number;
     readonly compat: "paper" | "networkx";
 }
+/** Spec 2.2 CalibrateOptions, verbatim: the probe sizes of calibrateLayout (default 8k / 16k / 32k / 65k). */
+export interface CalibrateOptions {
+    readonly sizes?: readonly number[] | undefined;
+}
+/**
+ * Spec 2.2 GpuCalibration, verbatim: the per-size ms per iteration of both repulsion tiers on the actual device,
+ * `pairsPerSecond` of the exact tier at the largest probed size, `suggestedExactMaxNodes` by the spec 7.8 rule
+ * (the largest probed n with exactMs(n) <= min(4 ms, gridMs(n)), rounded down to a power of two; when NO probed size
+ * qualifies -- the grid tier faster at every probe, or every probe over the budget -- the largest power of two strictly
+ * below the smallest probe, so the exact tier runs at no probed size and a value below floorPow2(min(sizes)) tells the
+ * caller the rule found nothing in the range: src/layouts/calibrate.ts) and the wall time of the whole call (pipeline
+ * compilation included on the first call).
+ */
+export interface GpuCalibration {
+    readonly pairsPerSecond: number;
+    readonly exactMsPerIter: Readonly<Record<number, number>>;
+    readonly gridMsPerIter: Readonly<Record<number, number>>;
+    readonly suggestedExactMaxNodes: number;
+    readonly firstCallMs: number;
+}
 //# sourceMappingURL=layout.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../src/types/layout.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../src/types/layout.ts"],"names":[],"mappings":"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"}

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/counting-scatter.wgsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The `counting-scatter` kernel body (spec 6 row 5; P4-T3): the scatter of a counting sort. `start[k]` is the
+ * exclusive scan of the histogram, `cursor[k]` a zeroed per-bin atomic; an element takes the slot `start[k] +
+ * atomicAdd(&cursor[k], 1u)`. The order inside a bin depends on the schedule (set-deterministic, design 6). Body
+ * only; normative text.
+ */
+export declare const countingScatterWgsl = "\n@compute @workgroup_size(WG)\nfn counting_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    let i = linear_id(wid, lid.x);\n    if (i >= P.count) { return; }                                  // no barrier follows\n    let k = keys[i];\n    let slot = atomicAdd(&cursor[k], 1u);                          // the per-bin cursor (6 row 5)\n    outIndex[start[k] + slot] = i;\n}\n";
+//# sourceMappingURL=counting-scatter.wgsl.d.ts.map

package/dist/src/wgsl/counting-scatter.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"counting-scatter.wgsl.d.ts","sourceRoot":"","sources":["../../../src/wgsl/counting-scatter.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,gbAS/B,CAAC"}

package/dist/src/wgsl/counting-scatter.wgsl.js

@@ -0,0 +1,17 @@
+/**
+ * The `counting-scatter` kernel body (spec 6 row 5; P4-T3): the scatter of a counting sort. `start[k]` is the
+ * exclusive scan of the histogram, `cursor[k]` a zeroed per-bin atomic; an element takes the slot `start[k] +
+ * atomicAdd(&cursor[k], 1u)`. The order inside a bin depends on the schedule (set-deterministic, design 6). Body
+ * only; normative text.
+ */
+export const countingScatterWgsl = /* wgsl */ `
+@compute @workgroup_size(WG)
+fn counting_scatter(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    let i = linear_id(wid, lid.x);
+    if (i >= P.count) { return; }                                  // no barrier follows
+    let k = keys[i];
+    let slot = atomicAdd(&cursor[k], 1u);                          // the per-bin cursor (6 row 5)
+    outIndex[start[k] + slot] = i;
+}
+`;
+//# sourceMappingURL=counting-scatter.wgsl.js.map

package/dist/src/wgsl/counting-scatter.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"counting-scatter.wgsl.js","sourceRoot":"","sources":["../../../src/wgsl/counting-scatter.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;CAS7C,CAAC"}

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

@@ -1,12 +1,27 @@
 /**
- * K2 of the ForceAtlas2 iteration, `fa2-attraction` (spec 7.5; contract 4.5): the thread-per-row gather of the
- * 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`).
+ * K2 of the ForceAtlas2 iteration, `fa2-attraction` (spec 7.5; contract 4.5): the gather of the 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 (or combined into it under `P.accumulate`, the windowed pattern of 4.2). The arcs are read
+ * inside the bound window [P.arcBase, P.arcEnd). P4-T5 (PD-6, PD-7) gives it the three degree tiers: TIER 0 is one
+ * row per thread over `[P.tierStart, P.tierEnd)`; TIER 1 is 32 lanes per row over `[P.hiEnd, P.midEnd)` with a
+ * five-step tree in workgroup memory; TIER 2 is one workgroup per row over `[0, P.hiEnd)` through `wg_reduce_vec4`
+ * (hence `needs: ["subgroups"]`); the row is `perm[row]` under USE_PERM. `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.
+ * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5, P5-T7, P4-T5 / T6) are
+ * textual edits of it.
+ *
+ * TIER 0 folds its row through `row_force_dense`, a stride-one copy of `row_force`, because the shader compiler
+ * emits `row_force(i, 0u, 1u)` as a call and leaves the stride in a parameter: the loop then walks the row with a
+ * runtime step, which costs the strength-reduced addressing into colIdx / weights and the unrolling that keeps
+ * several loads in flight per thread. TIER 0 runs on every load -- alone when no row reaches degree 32, and over
+ * the low-degree rows, which are most of them, when the tiers are bound. The two folds spell their locals apart
+ * (`arc` / `nbr` / `weight` / `total` against `a` / `j` / `w` / `f`) so that each sabotage row names exactly one
+ * of them.
  */
-/** 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}";
+/** The K2 body: entry point `attraction`; the tier bodies are functions called under the uniform `TIER` override, so the barriers of `tiered` are reached in uniform control flow and `tier0`'s early return is legal (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}\nfn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }\nfn row_node(row: u32) -> u32 { return select(row, perm[row], USE_PERM); }\nfn row_force(i: u32, lane: u32, step: u32) -> vec3f {           // the arcs of row i this lane walks inside the bound window [P.arcBase, P.arcEnd) (4.2)\n    let pi = pos[i];                                           // xyz + mass in one load (D23)\n    let a0 = max(rowPtr[i], P.arcBase);\n    let a1 = min(rowPtr[i + 1u], P.arcEnd);\n    var f = vec3f(0.0);\n    for (var a = a0 + lane; a < a1; a = a + step) {\n        let j = colIdx[a - P.arcBase];\n        if (j == i) { continue; }                              // a self-loop exerts no force\n        var w = 1.0;\n        if (HAS_WEIGHTS) { w = weights[a - P.arcBase]; }\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    return f;\n}\nfn row_force_dense(i: u32) -> vec3f {                          // TIER 0's stride-one twin of row_force (see the header)\n    let pi = pos[i];\n    let lo = max(rowPtr[i], P.arcBase);\n    let hi = min(rowPtr[i + 1u], P.arcEnd);\n    var total = vec3f(0.0);\n    for (var arc = lo; arc < hi; arc = arc + 1u) {\n        let k = arc - P.arcBase;                               // the window-local index; this walk is contiguous\n        let nbr = colIdx[k];\n        if (nbr == i) { continue; }                            // a self-loop exerts no force\n        var weight = 1.0;\n        if (HAS_WEIGHTS) { weight = weights[k]; }\n        let d = pos[nbr].xyz - pi.xyz;                         // toward the neighbour\n        let len = max(length(d), FA2_DIST_FLOOR);\n        if (LAW == 1u) { weight = length(d) / P.frK; }         // LAW 1 (FR, 7.20), as in row_force\n        if (LAW == 2u) { weight = P.springCoefficient * (len - P.springLength) / len; }   // LAW 2 (spring), as in row_force\n        let mag = select(weight, weight * log(1.0 + len) / len, LINLOG);\n        total = total + d * mag;\n    }\n    return total;\n}\nfn finish(i: u32, f0: vec3f) {\n    var f = f0;\n    if (DISTRIBUTED) { f = f / pos[i].w; }\n    if (P.accumulate == 1u) { f = f + load_force(i); }         // the windowed loop of 4.2 (arcBase != 0 dispatches after the first)\n    store_force(i, f);                                         // overwrites: attraction is the first writer of force each iteration\n}\nfn tier0(wid: vec3<u32>, lane: u32) {                          // TIER 0: one row per thread over [tierStart, tierEnd); no barrier, so the early return is legal (3.5 rule 1)\n    let row = linear_id(wid, lane) + P.tierStart;\n    if (row >= P.tierEnd) { return; }\n    let i = row_node(row);\n    finish(i, row_force_dense(i));\n}\n\nvar<workgroup> sh: array<vec3f, WG>;\n\nfn tiered(wid: vec3<u32>, lid: u32) {                          // TIER 1: 32 lanes per row over [hiEnd, midEnd); TIER 2: WG lanes per row over [0, hiEnd) (PD-6, PD-7)\n    let g = group_id(wid);\n    var row = g;\n    var end = P.hiEnd;\n    var lane = lid;\n    var step = WG;\n    if (TIER == 1u) { row = P.hiEnd + g * (WG / 32u) + lid / 32u; end = P.midEnd; lane = lid % 32u; step = 32u; }\n    let valid = row < end;\n    var i = 0u;\n    var f = vec3f(0.0);\n    if (valid) { i = row_node(row); f = row_force(i, lane, step); }\n    if (TIER == 1u) {\n        sh[lid] = f;\n        workgroupBarrier();\n        for (var s = 16u; s >= 1u; s = s / 2u) {                 // the five-step tree over each 32-lane group; every lane runs every step\n            var t = vec3f(0.0);\n            if (lane < s) { t = sh[lid + s]; }\n            workgroupBarrier();\n            sh[lid] = sh[lid] + t;\n            workgroupBarrier();\n        }\n        if (valid && lane == 0u) { finish(i, sh[lid]); }\n    }\n    if (TIER == 2u) {\n        let t = wg_reduce_vec4(vec4f(f, 0.0), lid, 0u);\n        if (valid && lid == 0u) { finish(i, t.xyz); }\n    }\n}\n\n@compute @workgroup_size(WG)\nfn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {\n    if (TIER == 0u) { tier0(wid, lid.x); } else { tiered(wid, lid.x); }\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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,4OAA4O;AAC5O,eAAO,MAAM,iBAAiB,msJA6F5B,CAAC"}

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

@@ -1,37 +1,120 @@
 /**
- * K2 of the ForceAtlas2 iteration, `fa2-attraction` (spec 7.5; contract 4.5): the thread-per-row gather of the
- * 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`).
+ * K2 of the ForceAtlas2 iteration, `fa2-attraction` (spec 7.5; contract 4.5): the gather of the 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 (or combined into it under `P.accumulate`, the windowed pattern of 4.2). The arcs are read
+ * inside the bound window [P.arcBase, P.arcEnd). P4-T5 (PD-6, PD-7) gives it the three degree tiers: TIER 0 is one
+ * row per thread over `[P.tierStart, P.tierEnd)`; TIER 1 is 32 lanes per row over `[P.hiEnd, P.midEnd)` with a
+ * five-step tree in workgroup memory; TIER 2 is one workgroup per row over `[0, P.hiEnd)` through `wg_reduce_vec4`
+ * (hence `needs: ["subgroups"]`); the row is `perm[row]` under USE_PERM. `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.
+ * Body only (spec 3.5, D9); normative text (contract 4.5); the K2 sabotage mutations (P3-T5, P5-T7, P4-T5 / T6) are
+ * textual edits of it.
+ *
+ * TIER 0 folds its row through `row_force_dense`, a stride-one copy of `row_force`, because the shader compiler
+ * emits `row_force(i, 0u, 1u)` as a call and leaves the stride in a parameter: the loop then walks the row with a
+ * runtime step, which costs the strength-reduced addressing into colIdx / weights and the unrolling that keeps
+ * several loads in flight per thread. TIER 0 runs on every load -- alone when no row reaches degree 32, and over
+ * the low-degree rows, which are most of them, when the tiers are bound. The two folds spell their locals apart
+ * (`arc` / `nbr` / `weight` / `total` against `a` / `j` / `w` / `f`) so that each sabotage row names exactly one
+ * of them.
  */
-/** The K2 body: entry point `attraction`; an early return is legal here because no barrier follows (spec 3.5 rule 1). */
+/** The K2 body: entry point `attraction`; the tier bodies are functions called under the uniform `TIER` override, so the barriers of `tiered` are reached in uniform control flow and `tier0`'s early return is legal (spec 3.5 rule 1). */
 export const fa2AttractionWgsl = /* wgsl */ `fn store_force(i: u32, f: vec3f) {
     force[3u * i] = f.x;
     force[3u * i + 1u] = f.y;
     force[3u * i + 2u] = f.z;
 }
-
-@compute @workgroup_size(WG)
-fn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
-    let row = linear_id(wid, lid.x) + P.tierStart;
-    if (row >= P.tierEnd) { return; }                          // no barrier follows in this tier (3.5 rule 1)
-    let i = select(row, perm[row], USE_PERM);
+fn load_force(i: u32) -> vec3f { return vec3f(force[3u * i], force[3u * i + 1u], force[3u * i + 2u]); }
+fn row_node(row: u32) -> u32 { return select(row, perm[row], USE_PERM); }
+fn row_force(i: u32, lane: u32, step: u32) -> vec3f {           // the arcs of row i this lane walks inside the bound window [P.arcBase, P.arcEnd) (4.2)
     let pi = pos[i];                                           // xyz + mass in one load (D23)
+    let a0 = max(rowPtr[i], P.arcBase);
+    let a1 = min(rowPtr[i + 1u], P.arcEnd);
     var f = vec3f(0.0);
-    for (var a = rowPtr[i]; a < rowPtr[i + 1u]; a = a + 1u) {
-        let j = colIdx[a];
+    for (var a = a0 + lane; a < a1; a = a + step) {
+        let j = colIdx[a - P.arcBase];
         if (j == i) { continue; }                              // a self-loop exerts no force
         var w = 1.0;
-        if (HAS_WEIGHTS) { w = weights[a]; }
+        if (HAS_WEIGHTS) { w = weights[a - P.arcBase]; }
         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;
     }
-    if (DISTRIBUTED) { f = f / pi.w; }
+    return f;
+}
+fn row_force_dense(i: u32) -> vec3f {                          // TIER 0's stride-one twin of row_force (see the header)
+    let pi = pos[i];
+    let lo = max(rowPtr[i], P.arcBase);
+    let hi = min(rowPtr[i + 1u], P.arcEnd);
+    var total = vec3f(0.0);
+    for (var arc = lo; arc < hi; arc = arc + 1u) {
+        let k = arc - P.arcBase;                               // the window-local index; this walk is contiguous
+        let nbr = colIdx[k];
+        if (nbr == i) { continue; }                            // a self-loop exerts no force
+        var weight = 1.0;
+        if (HAS_WEIGHTS) { weight = weights[k]; }
+        let d = pos[nbr].xyz - pi.xyz;                         // toward the neighbour
+        let len = max(length(d), FA2_DIST_FLOOR);
+        if (LAW == 1u) { weight = length(d) / P.frK; }         // LAW 1 (FR, 7.20), as in row_force
+        if (LAW == 2u) { weight = P.springCoefficient * (len - P.springLength) / len; }   // LAW 2 (spring), as in row_force
+        let mag = select(weight, weight * log(1.0 + len) / len, LINLOG);
+        total = total + d * mag;
+    }
+    return total;
+}
+fn finish(i: u32, f0: vec3f) {
+    var f = f0;
+    if (DISTRIBUTED) { f = f / pos[i].w; }
+    if (P.accumulate == 1u) { f = f + load_force(i); }         // the windowed loop of 4.2 (arcBase != 0 dispatches after the first)
     store_force(i, f);                                         // overwrites: attraction is the first writer of force each iteration
+}
+fn tier0(wid: vec3<u32>, lane: u32) {                          // TIER 0: one row per thread over [tierStart, tierEnd); no barrier, so the early return is legal (3.5 rule 1)
+    let row = linear_id(wid, lane) + P.tierStart;
+    if (row >= P.tierEnd) { return; }
+    let i = row_node(row);
+    finish(i, row_force_dense(i));
+}
+
+var<workgroup> sh: array<vec3f, WG>;
+
+fn tiered(wid: vec3<u32>, lid: u32) {                          // TIER 1: 32 lanes per row over [hiEnd, midEnd); TIER 2: WG lanes per row over [0, hiEnd) (PD-6, PD-7)
+    let g = group_id(wid);
+    var row = g;
+    var end = P.hiEnd;
+    var lane = lid;
+    var step = WG;
+    if (TIER == 1u) { row = P.hiEnd + g * (WG / 32u) + lid / 32u; end = P.midEnd; lane = lid % 32u; step = 32u; }
+    let valid = row < end;
+    var i = 0u;
+    var f = vec3f(0.0);
+    if (valid) { i = row_node(row); f = row_force(i, lane, step); }
+    if (TIER == 1u) {
+        sh[lid] = f;
+        workgroupBarrier();
+        for (var s = 16u; s >= 1u; s = s / 2u) {                 // the five-step tree over each 32-lane group; every lane runs every step
+            var t = vec3f(0.0);
+            if (lane < s) { t = sh[lid + s]; }
+            workgroupBarrier();
+            sh[lid] = sh[lid] + t;
+            workgroupBarrier();
+        }
+        if (valid && lane == 0u) { finish(i, sh[lid]); }
+    }
+    if (TIER == 2u) {
+        let t = wg_reduce_vec4(vec4f(f, 0.0), lid, 0u);
+        if (valid && lid == 0u) { finish(i, t.xyz); }
+    }
+}
+
+@compute @workgroup_size(WG)
+fn attraction(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
+    if (TIER == 0u) { tier0(wid, lid.x); } else { tiered(wid, lid.x); }
 }`;
 //# sourceMappingURL=fa2-attraction.wgsl.js.map

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;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,4OAA4O;AAC5O,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6F1C,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();