@graphty/algorithms 2.1.2 → 2.2.0

package/dist/src/indexed/closeness.js

@@ -0,0 +1,127 @@
+import { IndexedMinHeap } from "./structures/min-heap.js";
+/**
+ * Build the per-source scorer: a breadth-first search, or Dijkstra when `weighted`, then the legacy formula.
+ * @param s - The snapshot
+ * @param o - The options
+ * @returns The scorer
+ */
+function scorer(s, o) {
+    const { nodeCount: n, rowPtr, colIdx } = s;
+    const cutoff = o.cutoff ?? Infinity;
+    const weights = o.weighted === true ? (o.weights ?? s.weights) : null;
+    const dist = new Float64Array(n).fill(Infinity);
+    const reached = new Uint32Array(n);
+    const heap = weights === null ? null : new IndexedMinHeap(n);
+    // A popped node is final, as in the legacy search: without this a negative cycle never ends.
+    const settled = new Uint8Array(n);
+    /**
+     * Fill `dist` from the source and list the reached nodes in `reached`.
+     * @param source - The source index
+     * @returns How many nodes were reached, the source included
+     */
+    function search(source) {
+        let tail = 0;
+        dist[source] = 0;
+        reached[tail++] = source;
+        if (heap === null || weights === null) {
+            for (let head = 0; head < tail; head++) {
+                const v = reached[head];
+                if (dist[v] >= cutoff) {
+                    continue;
+                }
+                for (let a = rowPtr[v], end = rowPtr[v + 1]; a < end; a++) {
+                    const w = colIdx[a];
+                    if (dist[w] === Infinity) {
+                        dist[w] = dist[v] + 1;
+                        reached[tail++] = w;
+                    }
+                }
+            }
+            return tail;
+        }
+        heap.push(source, 0);
+        while (!heap.isEmpty()) {
+            const v = heap.pop();
+            settled[v] = 1;
+            if (dist[v] >= cutoff) {
+                continue;
+            }
+            for (let a = rowPtr[v], end = rowPtr[v + 1]; a < end; a++) {
+                const w = colIdx[a];
+                if (settled[w] === 1) {
+                    continue;
+                }
+                const d = dist[v] + weights[a];
+                if (d < dist[w]) {
+                    if (dist[w] === Infinity) {
+                        reached[tail++] = w;
+                    }
+                    dist[w] = d;
+                    heap.pushOrDecrease(w, d);
+                }
+            }
+        }
+        return tail;
+    }
+    return (source) => {
+        const count = search(source);
+        let score = 0;
+        let total = 0;
+        for (let i = 1; i < count; i++) {
+            const d = dist[reached[i]];
+            if (o.harmonic === true) {
+                score += d > 0 ? 1 / d : 0;
+            }
+            else {
+                total += d;
+            }
+        }
+        for (let i = 0; i < count; i++) {
+            dist[reached[i]] = Infinity;
+            settled[reached[i]] = 0;
+        }
+        if (o.harmonic === true) {
+            return o.normalized === true && n > 1 ? score / (n - 1) : score;
+        }
+        if (total <= 0) {
+            return 0;
+        }
+        return o.normalized === true && n > 1 ? (count - 1) / total / (n - 1) : 1 / total;
+    };
+}
+/**
+ * Closeness centrality of every node: `1 / sum(distance to each reached node)` by default, the legacy
+ * `closenessCentrality` (hops) and `weightedClosenessCentrality` (`weighted: true`) numbers. The weighted
+ * route reads the snapshot's f32 arc weights, so it matches legacy to f32 rounding; pass the f64 weights as
+ * `weights` for the exact legacy sums. As in legacy, a node's distance is final once it is searched from, so a
+ * negative weight gives the legacy (not the true shortest) distance and never loops. An unreached node adds
+ * nothing, and a node that reaches nothing scores 0.
+ * @param s - The snapshot
+ * @param options - Normalisation, harmonic form, cutoff and weights
+ * @returns One score per node index; `iterations` is the number of searches run
+ * @public
+ */
+export function closenessCentrality(s, options = {}) {
+    const score = scorer(s, options);
+    const scores = new Float64Array(s.nodeCount);
+    for (let v = 0; v < s.nodeCount; v++) {
+        scores[v] = score(v);
+    }
+    return { scores, iterations: s.nodeCount, converged: true };
+}
+/**
+ * Closeness centrality of one node, with one search rather than n.
+ * @param s - The snapshot
+ * @param node - The node index
+ * @param options - As {@link closenessCentrality}
+ * @returns The node's score
+ * @throws RangeError for a node index outside `[0, nodeCount)`
+ * @public
+ */
+export function nodeClosenessCentrality(s, node, options = {}) {
+    if (!Number.isInteger(node) || node < 0 || node >= s.nodeCount) {
+        throw new RangeError(`nodeClosenessCentrality: node must be an index in [0, ${s.nodeCount}), got ${node}`);
+    }
+    return scorer(s, options)(node);
+}
+//# sourceMappingURL=closeness.js.map

package/dist/src/indexed/closeness.js.map

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

package/dist/src/indexed/common-neighbors.d.ts

@@ -1,9 +1,22 @@
-import type { GraphSnapshot } from "@graphty/graph-format";
+import type { AdjacencyView, GraphSnapshot } from "@graphty/graph-format";
 /** Options of the index-based common-neighbour score. @public */
 export interface CommonNeighborsOptions {
     /** Intersect out(u) with in(v) instead of the two undirected rows. */
     readonly directed?: boolean | undefined;
 }
+/**
+ * Merge row u of `fwd` with row v of `bwd` (both sorted) and add up each DISTINCT common neighbour
+ * once: 1 per neighbour, or `weight(z)` when a weight function is given. Skipping the repeats of a
+ * match in row v gives simple-graph semantics on a multigraph; a repeat in row u is then smaller
+ * than the next entry of row v and the ordinary advance passes it.
+ * @param fwd - The view whose row u is read
+ * @param bwd - The view whose row v is read
+ * @param u - A node index
+ * @param v - A node index
+ * @param weight - Optional weight of a common neighbour
+ * @returns The count, or the weight sum, over distinct common neighbours
+ */
+export declare function sortedRowMerge(fwd: AdjacencyView, bwd: AdjacencyView, u: number, v: number, weight?: (z: number) => number): number;
 /**
  * The number of distinct common neighbours of two nodes, by a merge of their sorted rows.
  * @param s - The snapshot

package/dist/src/indexed/common-neighbors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common-neighbors.d.ts","sourceRoot":"","sources":["../../../src/indexed/common-neighbors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE1E,iEAAiE;AACjE,MAAM,WAAW,sBAAsB;IACnC,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAE,sBAA2B,GAAG,MAAM,CA4BnH"}
+{"version":3,"file":"common-neighbors.d.ts","sourceRoot":"","sources":["../../../src/indexed/common-neighbors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE1E,iEAAiE;AACjE,MAAM,WAAW,sBAAsB;IACnC,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC1B,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,aAAa,EAClB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAC/B,MAAM,CAuBR;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAE,sBAA2B,GAAG,MAAM,CAEnH"}

package/dist/src/indexed/common-neighbors.js

@@ -1,30 +1,28 @@
 /**
- * The number of distinct common neighbours of two nodes, by a merge of their sorted rows.
- * @param s - The snapshot
+ * Merge row u of `fwd` with row v of `bwd` (both sorted) and add up each DISTINCT common neighbour
+ * once: 1 per neighbour, or `weight(z)` when a weight function is given. Skipping the repeats of a
+ * match in row v gives simple-graph semantics on a multigraph; a repeat in row u is then smaller
+ * than the next entry of row v and the ordinary advance passes it.
+ * @param fwd - The view whose row u is read
+ * @param bwd - The view whose row v is read
  * @param u - A node index
  * @param v - A node index
- * @param o - Options
- * @returns The count of distinct common neighbours
- * @public
+ * @param weight - Optional weight of a common neighbour
+ * @returns The count, or the weight sum, over distinct common neighbours
  */
-export function commonNeighborsScore(s, u, v, o = {}) {
-    const fwd = s;
-    const bwd = o.directed === true ? s.reverse() : s;
+export function sortedRowMerge(fwd, bwd, u, v, weight) {
     let i = fwd.rowPtr[u];
     const iEnd = fwd.rowPtr[u + 1];
     let j = bwd.rowPtr[v];
     const jEnd = bwd.rowPtr[v + 1];
-    let count = 0;
+    let sum = 0;
     while (i < iEnd && j < jEnd) {
         const a = fwd.colIdx[i];
         const b = bwd.colIdx[j];
         if (a === b) {
-            count++;
+            sum += weight === undefined ? 1 : weight(a);
             i++;
             j++;
-            while (i < iEnd && fwd.colIdx[i] === a) {
-                i++;
-            }
             while (j < jEnd && bwd.colIdx[j] === b) {
                 j++;
             }
@@ -36,6 +34,18 @@ export function commonNeighborsScore(s, u, v, o = {}) {
             j++;
         }
     }
-    return count;
+    return sum;
+}
+/**
+ * The number of distinct common neighbours of two nodes, by a merge of their sorted rows.
+ * @param s - The snapshot
+ * @param u - A node index
+ * @param v - A node index
+ * @param o - Options
+ * @returns The count of distinct common neighbours
+ * @public
+ */
+export function commonNeighborsScore(s, u, v, o = {}) {
+    return sortedRowMerge(s, o.directed === true ? s.reverse() : s, u, v);
 }
 //# sourceMappingURL=common-neighbors.js.map

package/dist/src/indexed/common-neighbors.js.map

@@ -1 +1 @@
-{"version":3,"file":"common-neighbors.js","sourceRoot":"","sources":["../../../src/indexed/common-neighbors.ts"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAAC,CAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,IAA4B,EAAE;IACvG,MAAM,GAAG,GAAkB,CAAC,CAAC;IAC7B,MAAM,GAAG,GAAkB,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtB,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtB,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC;QAC1B,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACV,KAAK,EAAE,CAAC;YACR,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,CAAC;YACJ,OAAO,CAAC,GAAG,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrC,CAAC,EAAE,CAAC;YACR,CAAC;YACD,OAAO,CAAC,GAAG,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrC,CAAC,EAAE,CAAC;YACR,CAAC;QACL,CAAC;aAAM,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACf,CAAC,EAAE,CAAC;QACR,CAAC;aAAM,CAAC;YACJ,CAAC,EAAE,CAAC;QACR,CAAC;IACL,CAAC;IACD,OAAO,KAAK,CAAC;AACjB,CAAC"}
+{"version":3,"file":"common-neighbors.js","sourceRoot":"","sources":["../../../src/indexed/common-neighbors.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAC1B,GAAkB,EAClB,GAAkB,EAClB,CAAS,EACT,CAAS,EACT,MAA8B;IAE9B,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtB,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtB,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC;QAC1B,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACV,GAAG,IAAI,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YAC5C,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,CAAC;YACJ,OAAO,CAAC,GAAG,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrC,CAAC,EAAE,CAAC;YACR,CAAC;QACL,CAAC;aAAM,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACf,CAAC,EAAE,CAAC;QACR,CAAC;aAAM,CAAC;YACJ,CAAC,EAAE,CAAC;QACR,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACf,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAAC,CAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,IAA4B,EAAE;IACvG,OAAO,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1E,CAAC"}

package/dist/src/indexed/degree.d.ts

@@ -0,0 +1,19 @@
+import type { F64, GraphSnapshot } from "@graphty/graph-format";
+/** Options of the index-based degree centrality, matching the legacy `degreeCentrality`. @public */
+export interface DegreeCentralityOptions {
+    /** On a directed snapshot, which neighbours to count; ignored when undirected. Default `"total"`. */
+    readonly mode?: "in" | "out" | "total" | undefined;
+    /** Divide by `n - 1`, the most neighbours a node can have. Default false. */
+    readonly normalized?: boolean | undefined;
+}
+/**
+ * Degree centrality: each node's number of distinct neighbours (in, out, or both on a directed snapshot),
+ * optionally divided by `n - 1`. Equals the legacy `degreeCentrality` on every graph it can hold, and on a
+ * multigraph equals it on the same graph with each pair's parallel edges merged.
+ * @param s - The snapshot
+ * @param options - Direction and normalisation
+ * @returns One score per node index
+ * @public
+ */
+export declare function degreeCentrality(s: GraphSnapshot, options?: DegreeCentralityOptions): F64;
+//# sourceMappingURL=degree.d.ts.map

package/dist/src/indexed/degree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"degree.d.ts","sourceRoot":"","sources":["../../../src/indexed/degree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,GAAG,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE/E,oGAAoG;AACpG,MAAM,WAAW,uBAAuB;IACpC,qGAAqG;IACrG,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC;IACnD,6EAA6E;IAC7E,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7C;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,aAAa,EAAE,OAAO,GAAE,uBAA4B,GAAG,GAAG,CAgB7F"}

package/dist/src/indexed/degree.js

@@ -0,0 +1,45 @@
+/**
+ * Add each node's number of DISTINCT neighbours in `g` to `out`: parallel edges count once and a self-loop
+ * counts once, as the legacy `Graph.degree` counts them.
+ * @param g - The adjacency
+ * @param out - Per-node totals, added to in place
+ */
+function addDistinctNeighbours(g, out) {
+    const { rowPtr, colIdx } = g;
+    for (let v = 0; v < g.nodeCount; v++) {
+        let prev = -1;
+        for (let a = rowPtr[v], end = rowPtr[v + 1]; a < end; a++) {
+            if (colIdx[a] !== prev) {
+                prev = colIdx[a];
+                out[v]++;
+            }
+        }
+    }
+}
+/**
+ * Degree centrality: each node's number of distinct neighbours (in, out, or both on a directed snapshot),
+ * optionally divided by `n - 1`. Equals the legacy `degreeCentrality` on every graph it can hold, and on a
+ * multigraph equals it on the same graph with each pair's parallel edges merged.
+ * @param s - The snapshot
+ * @param options - Direction and normalisation
+ * @returns One score per node index
+ * @public
+ */
+export function degreeCentrality(s, options = {}) {
+    const scores = new Float64Array(s.nodeCount);
+    const mode = s.directed ? (options.mode ?? "total") : "out";
+    if (mode !== "in") {
+        addDistinctNeighbours(s, scores);
+    }
+    if (mode !== "out") {
+        addDistinctNeighbours(s.reverse(), scores);
+    }
+    const max = s.nodeCount - 1;
+    if (options.normalized === true && max > 0) {
+        for (let v = 0; v < scores.length; v++) {
+            scores[v] /= max;
+        }
+    }
+    return scores;
+}
+//# sourceMappingURL=degree.js.map

package/dist/src/indexed/degree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"degree.js","sourceRoot":"","sources":["../../../src/indexed/degree.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,SAAS,qBAAqB,CAAC,CAAgB,EAAE,GAAQ;IACrD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;QACd,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;YACxD,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;gBACrB,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;gBACjB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YACb,CAAC;QACL,CAAC;IACL,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,CAAgB,EAAE,UAAmC,EAAE;IACpF,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC7C,MAAM,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAC5D,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAChB,qBAAqB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IACrC,CAAC;IACD,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;QACjB,qBAAqB,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IACD,MAAM,GAAG,GAAG,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC;IAC5B,IAAI,OAAO,CAAC,UAAU,KAAK,IAAI,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;QACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC;QACrB,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC"}

package/dist/src/indexed/delta-pagerank.d.ts

@@ -0,0 +1,145 @@
+import type { F64, GraphSnapshot, NumericVector } from "@graphty/graph-format";
+import type { PageRankResult } from "./pagerank.js";
+/**
+ * The delta PageRank engines over snapshots: the `useDelta` path of the legacy `pageRank`
+ * ({@link deltaPageRank}), and the {@link DeltaPageRank} and {@link PriorityDeltaPageRank} engines.
+ * Each reproduces its legacy counterpart's arithmetic, including its quirks, so a facade over it
+ * gives the legacy answer: neighbours are visited in logical edge order (the legacy adjacency's
+ * insertion order), and every weight comes from the per-arc `weights` override when one is given.
+ * @module
+ */
+/** Options of {@link deltaPageRank}. @internal */
+export interface DeltaPageRankOptions {
+    /** Probability of following a link; default 0.85. */
+    readonly dampingFactor?: number | undefined;
+    /** Iteration cap; default 100. */
+    readonly maxIterations?: number | undefined;
+    /** Stop when no score moved by this much or more in one iteration (L-infinity); default 1e-6. */
+    readonly tolerance?: number | undefined;
+    /** Use arc weights; default false. */
+    readonly weighted?: boolean | undefined;
+    /** Per-arc weight override, arcCount long -- a facade passes `expandEdges(s, shadow.data)`. */
+    readonly weights?: NumericVector | undefined;
+    /** Starting score per node index, nodeCount long; normalised to sum 1. Default 1 / n each. */
+    readonly initialRanks?: NumericVector | undefined;
+    /** Teleport distribution per node index, nodeCount long; normalised to sum 1. Default uniform. */
+    readonly personalization?: NumericVector | undefined;
+}
+/** Options of {@link DeltaPageRank}'s and {@link PriorityDeltaPageRank}'s constructors. @public */
+export interface DeltaPageRankEngineOptions {
+    /** Per-arc weight override, arcCount long; default the snapshot's own arc weights. */
+    readonly weights?: NumericVector | undefined;
+}
+/** Options of {@link DeltaPageRank.compute} and {@link PriorityDeltaPageRank.computeWithPriority}. @public */
+export interface DeltaPageRankComputeOptions {
+    /** Probability of following a link; default 0.85. */
+    readonly dampingFactor?: number | undefined;
+    /** Stop when every pending delta is below this; default 1e-6. */
+    readonly tolerance?: number | undefined;
+    /** Rounds (DeltaPageRank) or processed nodes (PriorityDeltaPageRank); default 100. */
+    readonly maxIterations?: number | undefined;
+    /** A delta below this is dropped rather than propagated; default tolerance / 10. */
+    readonly deltaThreshold?: number | undefined;
+    /** Split a node's delta by arc weight instead of evenly; default false. */
+    readonly weighted?: boolean | undefined;
+    /**
+     * Teleport distribution per node index, nodeCount long; normalised to sum 1.
+     * {@link DeltaPageRank} only: the priority engine ignores it, as its legacy counterpart does.
+     */
+    readonly personalization?: NumericVector | undefined;
+}
+/**
+ * PageRank by power iteration with an L-infinity stopping rule: the `useDelta` path of the legacy
+ * `pageRank`, which it takes when `useDelta !== false` and the graph has more than 100 nodes. Its
+ * other path runs the same iteration, so this answers both. A node with no out-arcs is dangling
+ * and its rank is spread over every node (by the personalization when one is given); a node whose
+ * out-weights sum to 0 but has arcs is not dangling and passes nothing on, as in legacy.
+ *
+ * Not in the `indexed` namespace: it propagates no deltas, and it exists only so the legacy
+ * `pageRank` facade can reproduce legacy arithmetic exactly. Snapshot callers use
+ * `indexed.pageRank`.
+ * @param s - A DIRECTED snapshot
+ * @param o - Algorithm options
+ * @returns The scores, the iteration count and the convergence flag
+ * @internal
+ */
+export declare function deltaPageRank(s: GraphSnapshot, o?: DeltaPageRankOptions): PageRankResult;
+/**
+ * Delta-propagating PageRank that keeps its state between calls, as the legacy `DeltaPageRank`
+ * does: each round, every active node with a delta of at least `deltaThreshold` adds it to its
+ * score and pushes `dampingFactor * delta` along its out-arcs; the teleport share is added to
+ * every node's next delta each round, and the scores are normalised at the end. The out-weights
+ * that split a delta are the WEIGHTED out-degrees even when `weighted` is false -- legacy's
+ * arithmetic, kept so the two agree.
+ * @public
+ */
+export declare class DeltaPageRank {
+    private readonly s;
+    private readonly order;
+    private readonly weights;
+    private readonly outW;
+    private readonly scores;
+    private deltas;
+    private active;
+    /**
+     * Start every node at score 0 with a pending delta of 1 / n, all active.
+     * @param s - A DIRECTED snapshot
+     * @param o - The per-arc weight override
+     */
+    constructor(s: GraphSnapshot, o?: DeltaPageRankEngineOptions);
+    /**
+     * Propagate deltas until none is active, every pending delta is below `tolerance`, or
+     * `maxIterations` rounds have run; then normalise the scores.
+     * @param o - Algorithm options
+     * @returns A copy of the scores per node index
+     */
+    compute(o?: DeltaPageRankComputeOptions): F64;
+    /**
+     * Make only the given nodes and their in- and out-neighbours active, then {@link compute}.
+     * An index outside the graph names nothing and is skipped, but a non-empty `modified` still
+     * starts a round, as legacy does for an id the graph lacks. The snapshot is frozen, so this
+     * re-runs over the same graph; a changed graph is a new snapshot and a new engine.
+     * @param modified - Node indices to reactivate
+     * @param o - Algorithm options
+     * @returns A copy of the scores per node index
+     */
+    update(modified: ArrayLike<number>, o?: DeltaPageRankComputeOptions): F64;
+    /**
+     * The propagation rounds behind {@link compute} and {@link update}.
+     * @param o - Algorithm options
+     * @param startRound - Run the first round even when no node is active
+     * @returns A copy of the scores per node index
+     */
+    private run;
+}
+/**
+ * Delta PageRank processed one node at a time, largest pending delta first, keeping its state
+ * between calls as the legacy `PriorityDeltaPageRank` does. `maxIterations` counts processed
+ * nodes; every 1000 of them the run stops if no pending delta reaches `tolerance`. At the end
+ * each pending delta of at least `deltaThreshold` is added to its score (and stays pending), the
+ * teleport share is added, and the scores are normalised. The out-weights are the WEIGHTED
+ * out-degrees even when `weighted` is false, as in legacy.
+ * @public
+ */
+export declare class PriorityDeltaPageRank {
+    private readonly s;
+    private readonly order;
+    private readonly weights;
+    private readonly outW;
+    private readonly scores;
+    private readonly deltas;
+    private readonly heap;
+    /**
+     * Start every node at score 0 with a pending delta of 1 / n, queued in index order.
+     * @param s - A DIRECTED snapshot
+     * @param o - The per-arc weight override
+     */
+    constructor(s: GraphSnapshot, o?: DeltaPageRankEngineOptions);
+    /**
+     * Process queued nodes, largest pending delta first.
+     * @param o - Algorithm options; `personalization` is ignored
+     * @returns A copy of the scores per node index
+     */
+    computeWithPriority(o?: DeltaPageRankComputeOptions): F64;
+}
+//# sourceMappingURL=delta-pagerank.d.ts.map

package/dist/src/indexed/delta-pagerank.d.ts.map

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