hoi4-agent-tools 4.3.0 → 4.5.0

package/dist/hoi4_agent_tools/map/partition-groups.js

@@ -0,0 +1,164 @@
+/** A binary max-heap keyed by score, then by the lower ids. */
+class CandidateHeap {
+    #items = [];
+    get size() {
+        return this.#items.length;
+    }
+    static #before(x, y) {
+        if (x.score !== y.score)
+            return x.score > y.score;
+        if (x.a !== y.a)
+            return x.a < y.a;
+        return x.b < y.b;
+    }
+    push(item) {
+        const items = this.#items;
+        let i = items.length;
+        items.push(item);
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            if (!CandidateHeap.#before(items[i], items[parent]))
+                break;
+            [items[i], items[parent]] = [items[parent], items[i]];
+            i = parent;
+        }
+    }
+    pop() {
+        const items = this.#items;
+        if (items.length === 0)
+            return undefined;
+        const top = items[0];
+        const last = items.pop();
+        if (items.length > 0) {
+            items[0] = last;
+            let i = 0;
+            for (;;) {
+                const l = i * 2 + 1;
+                const r = l + 1;
+                let best = i;
+                if (l < items.length && CandidateHeap.#before(items[l], items[best]))
+                    best = l;
+                if (r < items.length && CandidateHeap.#before(items[r], items[best]))
+                    best = r;
+                if (best === i)
+                    break;
+                [items[i], items[best]] = [items[best], items[i]];
+                i = best;
+            }
+        }
+        return top;
+    }
+}
+/**
+ * Cluster `members` (province ids) over the graph. Returns the cluster of every member, numbered
+ * from 0 by the smallest member id of each cluster.
+ */
+export function clusterProvinces(members, graph, options, hooks = {}) {
+    const lambda = options.lambda ?? 12;
+    const hard = options.hardBarrier ?? 0.6;
+    const unlike = options.unlikeGround ?? 0.55;
+    const sorted = [...members].sort((a, b) => a - b);
+    const local = new Map(sorted.map((id, index) => [id, index]));
+    const n = sorted.length;
+    const sizeOf = new Int32Array(n).fill(1);
+    const perimeter = new Float64Array(n);
+    const version = new Int32Array(n);
+    const alive = new Uint8Array(n).fill(1);
+    const affinity = Array.from({ length: n }, () => new Map());
+    const shared = Array.from({ length: n }, () => new Map());
+    for (let i = 0; i < n; i++) {
+        const id = sorted[i];
+        for (let e = graph.offsets[id]; e < graph.offsets[id + 1]; e++) {
+            perimeter[i] += graph.length[e];
+            const other = local.get(graph.to[e]);
+            if (other === undefined || other === i)
+                continue;
+            if (hooks.group !== undefined && hooks.group(id) !== hooks.group(graph.to[e]))
+                continue;
+            const strength = graph.barrier[e];
+            const damp = 1 / ((1 + lambda * strength) * (1 + lambda * strength));
+            let weight = graph.length[e] * damp;
+            if (strength > hard)
+                weight *= 0.05;
+            if (hooks.label !== undefined && hooks.label(id) !== hooks.label(graph.to[e]))
+                weight *= unlike;
+            affinity[i].set(other, weight);
+            shared[i].set(other, graph.length[e]);
+        }
+    }
+    const heap = new CandidateHeap();
+    const scoreOf = (a, b) => {
+        const total = sizeOf[a] + sizeOf[b];
+        if (total > options.max)
+            return 0;
+        let factor = total <= options.target ? 1 : (options.max - total) / (options.max - options.target + 1);
+        const small = Math.min(sizeOf[a], sizeOf[b]) < options.min;
+        if (small)
+            factor = Math.max(factor, 0.05) * 2;
+        if (factor <= 0)
+            return 0;
+        const base = affinity[a].get(b);
+        return (base / Math.sqrt(Math.max(1, perimeter[a]) * Math.max(1, perimeter[b]))) * factor;
+    };
+    const offer = (a, b) => {
+        const low = Math.min(a, b);
+        const high = Math.max(a, b);
+        const score = scoreOf(low, high);
+        if (score > 0)
+            heap.push({ score, a: low, b: high, versionA: version[low], versionB: version[high] });
+    };
+    for (let i = 0; i < n; i++)
+        for (const other of affinity[i].keys())
+            if (other > i)
+                offer(i, other);
+    const parent = Int32Array.from({ length: n }, (_, i) => i);
+    for (let top = heap.pop(); top !== undefined; top = heap.pop()) {
+        const { a, b } = top;
+        if (!alive[a] || !alive[b] || version[a] !== top.versionA || version[b] !== top.versionB)
+            continue;
+        // Merge b into a. Only pairs that involve a change, so only a's version moves on.
+        const between = shared[a].get(b) ?? 0;
+        perimeter[a] = perimeter[a] + perimeter[b] - 2 * between;
+        sizeOf[a] += sizeOf[b];
+        alive[b] = 0;
+        parent[b] = a;
+        affinity[a].delete(b);
+        shared[a].delete(b);
+        for (const [c, weight] of affinity[b]) {
+            if (c === a)
+                continue;
+            const combined = (affinity[a].get(c) ?? 0) + weight;
+            const length = (shared[a].get(c) ?? 0) + (shared[b].get(c) ?? 0);
+            affinity[a].set(c, combined);
+            shared[a].set(c, length);
+            affinity[c].delete(b);
+            shared[c].delete(b);
+            affinity[c].set(a, combined);
+            shared[c].set(a, length);
+        }
+        affinity[b].clear();
+        shared[b].clear();
+        version[a]++;
+        for (const c of affinity[a].keys())
+            offer(a, c);
+    }
+    // Number clusters by their smallest member (members are sorted, so the first one seen).
+    const root = (i) => {
+        let r = i;
+        while (parent[r] !== r)
+            r = parent[r];
+        return r;
+    };
+    const dense = new Map();
+    const result = new Map();
+    for (let i = 0; i < n; i++) {
+        const r = root(i);
+        let id = dense.get(r);
+        if (id === undefined) {
+            id = dense.size;
+            dense.set(r, id);
+        }
+        result.set(sorted[i], id);
+    }
+    return result;
+}