@thi.ng/adjacency 2.5.12 → 2.5.13

package/floyd-warshall.js

@@ -1,106 +1,84 @@
 import { outOfBounds } from "@thi.ng/errors/out-of-bounds";
-/**
- * Implementation of the Floyd-Warshall algorithm for finding _all_ shortest
- * paths in a directed graph, optionally with positive or negative edge weights.
- * A single execution of the algorithm will find the lengths (summed weights) of
- * shortest paths between all pairs of vertices.
- *
- * @remarks
- * The default cost function is topological distance (i.e. every edge has a
- * length/cost of 1).
- *
- * Paths & accumulated distances can be queried via {@link FloydWarshall.path}
- * and {@link FloydWarshall.distance}.
- *
- * This algorithm is quite memory hungry and requires `|V| * |V| * 8 bytes`,
- * i.e. ~8MB for a graph with 1000 nodes. If possible, use {@link BFS} to
- * perform individual shortest-path queries (rather than this global approach).
- *
- * Reference:
- * - https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm
- */
-export class FloydWarshall {
-    dist;
-    next;
-    numV;
-    /**
-     * Instantiates and pre-computes all shortest paths in given `graph`. See
-     * class comments for details.
-     *
-     * @param graph
-     * @param cost
-     */
-    constructor(graph, cost = () => 1) {
-        const numV = (this.numV = graph.numVertices());
-        const dist = (this.dist = new Float32Array(numV * numV).fill(Infinity));
-        const next = (this.next = new Int32Array(numV * numV).fill(-1));
-        for (let [u, v] of graph.edges()) {
-            const idx = u * numV + v;
-            dist[idx] = cost(u, v);
-            next[idx] = v;
-        }
-        for (let v = 0; v < numV; v++) {
-            const idx = v * numV + v;
-            dist[idx] = 0;
-            next[idx] = v;
-        }
-        for (let k = 0; k < numV; k++) {
-            for (let i = 0; i < numV; i++) {
-                const idxIK = i * numV + k;
-                for (let j = 0; j < numV; j++) {
-                    const idxIJ = i * numV + j;
-                    const idxKJ = k * numV + j;
-                    const minD = dist[idxIK] + dist[idxKJ];
-                    if (dist[idxIJ] > minD) {
-                        dist[idxIJ] = minD;
-                        next[idxIJ] = next[idxIK];
-                    }
-                }
-            }
-        }
+class FloydWarshall {
+  dist;
+  next;
+  numV;
+  /**
+   * Instantiates and pre-computes all shortest paths in given `graph`. See
+   * class comments for details.
+   *
+   * @param graph
+   * @param cost
+   */
+  constructor(graph, cost = () => 1) {
+    const numV = this.numV = graph.numVertices();
+    const dist = this.dist = new Float32Array(numV * numV).fill(Infinity);
+    const next = this.next = new Int32Array(numV * numV).fill(-1);
+    for (let [u, v] of graph.edges()) {
+      const idx = u * numV + v;
+      dist[idx] = cost(u, v);
+      next[idx] = v;
     }
-    /**
-     * Returns shortest distance between vertices `a` and `b`, or `undefined` if
-     * no connecting path exists. Throws an error if either `a` or `b` are out
-     * of bounds.
-     *
-     * @param a
-     * @param b
-     */
-    distance(a, b) {
-        this.ensurePair(a, b);
-        return this.dist[a * this.numV + b];
+    for (let v = 0; v < numV; v++) {
+      const idx = v * numV + v;
+      dist[idx] = 0;
+      next[idx] = v;
     }
-    /**
-     * Returns iterator of vertex IDs of path between `a` and `b` (if any).
-     * Throws an error if either `a` or `b` are out of bounds.
-     *
-     * @param a
-     * @param b
-     */
-    *path(a, b) {
-        this.ensurePair(a, b);
-        const { next, numV } = this;
-        if (next[a * numV + b] === -1)
-            return;
-        yield a;
-        while (a !== b) {
-            a = next[a * numV + b];
-            yield a;
+    for (let k = 0; k < numV; k++) {
+      for (let i = 0; i < numV; i++) {
+        const idxIK = i * numV + k;
+        for (let j = 0; j < numV; j++) {
+          const idxIJ = i * numV + j;
+          const idxKJ = k * numV + j;
+          const minD = dist[idxIK] + dist[idxKJ];
+          if (dist[idxIJ] > minD) {
+            dist[idxIJ] = minD;
+            next[idxIJ] = next[idxIK];
+          }
         }
+      }
     }
-    ensureIndex(id) {
-        !(id >= 0 && id < this.numV) && outOfBounds(id);
-    }
-    ensurePair(a, b) {
-        this.ensureIndex(a);
-        this.ensureIndex(b);
+  }
+  /**
+   * Returns shortest distance between vertices `a` and `b`, or `undefined` if
+   * no connecting path exists. Throws an error if either `a` or `b` are out
+   * of bounds.
+   *
+   * @param a
+   * @param b
+   */
+  distance(a, b) {
+    this.ensurePair(a, b);
+    return this.dist[a * this.numV + b];
+  }
+  /**
+   * Returns iterator of vertex IDs of path between `a` and `b` (if any).
+   * Throws an error if either `a` or `b` are out of bounds.
+   *
+   * @param a
+   * @param b
+   */
+  *path(a, b) {
+    this.ensurePair(a, b);
+    const { next, numV } = this;
+    if (next[a * numV + b] === -1)
+      return;
+    yield a;
+    while (a !== b) {
+      a = next[a * numV + b];
+      yield a;
     }
+  }
+  ensureIndex(id) {
+    !(id >= 0 && id < this.numV) && outOfBounds(id);
+  }
+  ensurePair(a, b) {
+    this.ensureIndex(a);
+    this.ensureIndex(b);
+  }
 }
-/**
- * Factory function for {@link FloydWarshall}.
- *
- * @param graph
- * @param cost
- */
-export const floydWarshall = (graph, cost) => new FloydWarshall(graph, cost);
+const floydWarshall = (graph, cost) => new FloydWarshall(graph, cost);
+export {
+  FloydWarshall,
+  floydWarshall
+};

package/list.js

@@ -1,138 +1,141 @@
 import { __into, __invert, __toDot } from "./utils.js";
-export class AdjacencyList {
-    adjacency = [];
-    indegree = [];
-    numE = 0;
-    numV = 0;
-    constructor(edges) {
-        edges && __into(this, edges);
-    }
-    numEdges() {
-        return this.numE;
-    }
-    numVertices() {
-        return this.numV;
-    }
-    *vertices() {
-        const { adjacency } = this;
-        for (let i = 0, n = adjacency.length; i < n; i++) {
-            if (adjacency[i])
-                yield i;
-        }
-    }
-    *edges() {
-        const { adjacency } = this;
-        for (let i = 0, n = adjacency.length; i < n; i++) {
-            const vertex = adjacency[i];
-            if (!vertex)
-                continue;
-            for (let j of vertex)
-                yield [i, j];
-        }
-    }
-    addVertex(id) {
-        this.ensureVertexData(id);
-    }
-    removeVertex(id) {
-        const { adjacency, indegree } = this;
-        const vertex = adjacency[id];
-        if (!vertex)
-            return false;
-        // remove outgoing
-        while (vertex.length) {
-            indegree[vertex.pop()]--;
-            this.numE--;
-        }
-        delete adjacency[id];
-        // remove incoming
-        for (let i = 0, n = adjacency.length; i < n && indegree[id] > 0; i++) {
-            const vertex = adjacency[i];
-            if (!vertex)
-                continue;
-            while (vertex.includes(id))
-                this.removeEdge(i, id);
-        }
-        this.numV--;
+class AdjacencyList {
+  adjacency = [];
+  indegree = [];
+  numE = 0;
+  numV = 0;
+  constructor(edges) {
+    edges && __into(this, edges);
+  }
+  numEdges() {
+    return this.numE;
+  }
+  numVertices() {
+    return this.numV;
+  }
+  *vertices() {
+    const { adjacency } = this;
+    for (let i = 0, n = adjacency.length; i < n; i++) {
+      if (adjacency[i])
+        yield i;
+    }
+  }
+  *edges() {
+    const { adjacency } = this;
+    for (let i = 0, n = adjacency.length; i < n; i++) {
+      const vertex = adjacency[i];
+      if (!vertex)
+        continue;
+      for (let j of vertex)
+        yield [i, j];
+    }
+  }
+  addVertex(id) {
+    this.ensureVertexData(id);
+  }
+  removeVertex(id) {
+    const { adjacency, indegree } = this;
+    const vertex = adjacency[id];
+    if (!vertex)
+      return false;
+    while (vertex.length) {
+      indegree[vertex.pop()]--;
+      this.numE--;
+    }
+    delete adjacency[id];
+    for (let i = 0, n = adjacency.length; i < n && indegree[id] > 0; i++) {
+      const vertex2 = adjacency[i];
+      if (!vertex2)
+        continue;
+      while (vertex2.includes(id))
+        this.removeEdge(i, id);
+    }
+    this.numV--;
+    return true;
+  }
+  hasVertex(id) {
+    return !!this.adjacency[id];
+  }
+  addEdge(from, to) {
+    const vertex = this.ensureVertexData(from);
+    this.ensureVertexData(to);
+    vertex.push(to);
+    this.indegree[to]++;
+    this.numE++;
+    return true;
+  }
+  removeEdge(from, to) {
+    const vertex = this.adjacency[from];
+    if (vertex) {
+      const dest = vertex.indexOf(to);
+      if (dest >= 0) {
+        vertex.splice(dest, 1);
+        this.numE--;
+        this.indegree[to]--;
         return true;
-    }
-    hasVertex(id) {
-        return !!this.adjacency[id];
-    }
-    addEdge(from, to) {
-        const vertex = this.ensureVertexData(from);
-        this.ensureVertexData(to);
-        vertex.push(to);
-        this.indegree[to]++;
-        this.numE++;
-        return true;
-    }
-    removeEdge(from, to) {
-        const vertex = this.adjacency[from];
-        if (vertex) {
-            const dest = vertex.indexOf(to);
-            if (dest >= 0) {
-                vertex.splice(dest, 1);
-                this.numE--;
-                this.indegree[to]--;
-                return true;
-            }
-        }
-        return false;
-    }
-    hasEdge(from, to) {
-        const vertex = this.adjacency[from];
-        return vertex ? vertex.includes(to) : false;
-    }
-    degree(id, type = "out") {
-        let degree = 0;
-        const vertex = this.adjacency[id];
-        if (vertex) {
-            if (type !== "in")
-                degree += vertex.length;
-            if (type !== "out")
-                degree += this.indegree[id];
-        }
-        return degree;
-    }
-    neighbors(id) {
-        return [...(this.adjacency[id] || [])];
-    }
-    invert() {
-        return __invert(new AdjacencyList(), this.edges());
-    }
-    toDot(ids) {
-        return __toDot(this.edges(), false, ids);
-    }
-    toString() {
-        const { adjacency } = this;
-        const res = [];
-        for (let i = 0, n = adjacency.length; i < n; i++) {
-            if (adjacency[i]) {
-                res.push(`${i}: [${[...adjacency[i]]
-                    .sort((a, b) => a - b)
-                    .join(", ")}]`);
-            }
-        }
-        return res.join("\n");
-    }
-    ensureVertexData(id) {
-        const vertex = this.adjacency[id];
-        if (vertex)
-            return vertex;
-        this.numV++;
-        this.indegree[id] = 0;
-        return (this.adjacency[id] = []);
-    }
+      }
+    }
+    return false;
+  }
+  hasEdge(from, to) {
+    const vertex = this.adjacency[from];
+    return vertex ? vertex.includes(to) : false;
+  }
+  degree(id, type = "out") {
+    let degree = 0;
+    const vertex = this.adjacency[id];
+    if (vertex) {
+      if (type !== "in")
+        degree += vertex.length;
+      if (type !== "out")
+        degree += this.indegree[id];
+    }
+    return degree;
+  }
+  neighbors(id) {
+    return [...this.adjacency[id] || []];
+  }
+  invert() {
+    return __invert(new AdjacencyList(), this.edges());
+  }
+  toDot(ids) {
+    return __toDot(this.edges(), false, ids);
+  }
+  toString() {
+    const { adjacency } = this;
+    const res = [];
+    for (let i = 0, n = adjacency.length; i < n; i++) {
+      if (adjacency[i]) {
+        res.push(
+          `${i}: [${[...adjacency[i]].sort((a, b) => a - b).join(", ")}]`
+        );
+      }
+    }
+    return res.join("\n");
+  }
+  ensureVertexData(id) {
+    const vertex = this.adjacency[id];
+    if (vertex)
+      return vertex;
+    this.numV++;
+    this.indegree[id] = 0;
+    return this.adjacency[id] = [];
+  }
 }
-export const defAdjList = (edges) => new AdjacencyList(edges);
-export const adjListFromAdjacency = (src) => {
-    const res = new AdjacencyList();
-    for (let i = 0, n = src.length; i < n; i++) {
-        const v = src[i];
-        if (!v)
-            continue;
-        for (let w of v)
-            res.addEdge(i, w);
-    }
-    return res;
+const defAdjList = (edges) => new AdjacencyList(edges);
+const adjListFromAdjacency = (src) => {
+  const res = new AdjacencyList();
+  for (let i = 0, n = src.length; i < n; i++) {
+    const v = src[i];
+    if (!v)
+      continue;
+    for (let w of v)
+      res.addEdge(i, w);
+  }
+  return res;
+};
+export {
+  AdjacencyList,
+  adjListFromAdjacency,
+  defAdjList
 };

package/mst.js

@@ -1,64 +1,17 @@
 import { sortByCachedKey } from "@thi.ng/arrays/sort-cached";
 import { DisjointSet } from "./disjoint-set.js";
-/**
- * Computes the Minimum Spanning Tree from given weighted `edges`, using
- * Kruskal's algorithm (O(E log V)).
- *
- * @remarks
- * Edges can be of any type, but requires unsigned integer vertex IDs. The
- * latter can be extracted via the user supplied `verts` function. The edge
- * weights are extracted via the `cost` function.
- *
- * The `maxID` arg should equal or greater than the largest vertex ID referenced
- * by the given edges.
- *
- * The function returns a new array of the original edges, satisfying the MST
- * criteria. The result edges will be in ascending order, based on the supplied
- * cost function. The cost function is called once for each edge and return
- * values will be cached prior to sorting (see
- * [`sortByCachedKey()`](https://docs.thi.ng/umbrella/arrays/functions/sortByCachedKey.html)
- * for details).
- *
- * References:
- * - https://en.wikipedia.org/wiki/Kruskal%27s_algorithm
- *
- * @example
- * ```ts
- * // 2D vectors
- * verts = [[0,0], [0,1], [1,1], [1,2], [4,2]]
- *
- * // connections (vertex ID pairs)
- * edges = [[0,1], [0,4], [1,2], [1,3], [2,3], [2,4]]
- *
- * mst(
- *   edges,
- *   // max vertex ID
- *   4,
- *   // cost function (cartesian distance, from @thi.ng/vectors pkg)
- *   ([a,b]) => distSq(verts[a], verts[b]),
- *   // edge vertex IDs
- *   (e) => e
- * )
- *
- * // [ [ 0, 1 ], [ 1, 2 ], [ 2, 3 ], [ 2, 4 ] ]
- * ```
- *
- * @param edges - edge pairs
- * @param maxID - max vertex ID (+1)
- * @param cost - cost function
- * @param verts - vertices / graph nodes
- *
- * @typeParam T - edge type
- */
-export const mst = (edges, maxID, cost, verts) => {
-    const graph = new DisjointSet(maxID + 1);
-    const res = [];
-    for (let e of sortByCachedKey(edges, cost)) {
-        const v = verts(e);
-        if (!graph.unified(v[0], v[1])) {
-            graph.union(v[0], v[1]);
-            res.push(e);
-        }
+const mst = (edges, maxID, cost, verts) => {
+  const graph = new DisjointSet(maxID + 1);
+  const res = [];
+  for (let e of sortByCachedKey(edges, cost)) {
+    const v = verts(e);
+    if (!graph.unified(v[0], v[1])) {
+      graph.union(v[0], v[1]);
+      res.push(e);
     }
-    return res;
+  }
+  return res;
+};
+export {
+  mst
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/adjacency",
-  "version": "2.5.12",
+  "version": "2.5.13",
   "description": "Sparse & bitwise adjacency matrices, lists and selected traversal algorithms for directed & undirected graphs",
   "type": "module",
   "module": "./index.js",
@@ -27,7 +27,9 @@
   ],
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -36,16 +38,17 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/arrays": "^2.7.7",
-    "@thi.ng/bitfield": "^2.3.9",
-    "@thi.ng/dcons": "^3.2.76",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/sparse": "^0.3.81"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/arrays": "^2.7.8",
+    "@thi.ng/bitfield": "^2.3.10",
+    "@thi.ng/dcons": "^3.2.77",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/sparse": "^0.3.82"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/vectors": "^7.8.8",
+    "@thi.ng/vectors": "^7.8.9",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -123,5 +126,5 @@
     ],
     "year": 2018
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }