@thi.ng/adjacency 2.5.12 → 2.5.14

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-18T13:41:19Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/api.js

@@ -1 +0,0 @@
-export {};

package/bfs.js

@@ -1,85 +1,55 @@
 import { BitField } from "@thi.ng/bitfield/bitfield";
 import { DCons } from "@thi.ng/dcons/dcons";
-/**
- * Breadth-First / shortest path search between `src` and `dest` in `graph`,
- * with optional `cost` function. By default all edges have an uniform cost,
- * i.e. the overall path cost is topological distance.
- *
- * @remarks
- * Also see {@link bfs} for ad hoc queries.
- *
- * Reference:
- * - https://en.wikipedia.org/wiki/Breadth-first_search
- * - https://algs4.cs.princeton.edu/40graphs/
- */
-export class BFS {
-    graph;
-    marked;
-    edges;
-    dist;
-    constructor(graph, src, cost = () => 1) {
-        this.graph = graph;
-        const numV = graph.numVertices();
-        this.edges = new Uint32Array(numV);
-        this.dist = new Float32Array(numV);
-        this.marked = new BitField(numV);
-        this.search(src, cost);
-    }
-    search(id, cost) {
-        const queue = new DCons();
-        queue.prepend(id);
-        const { dist, edges, graph, marked } = this;
-        dist.fill(0xffffffff);
-        dist[id] = 0;
-        marked.setAt(id);
-        while (queue.length) {
-            const v = queue.drop();
-            for (let n of graph.neighbors(v)) {
-                const c = dist[v] + cost(v, n);
-                if (c < dist[n] || !marked.at(n)) {
-                    edges[n] = v;
-                    dist[n] = c;
-                    marked.setAt(n);
-                    queue.push(n);
-                }
-            }
+class BFS {
+  graph;
+  marked;
+  edges;
+  dist;
+  constructor(graph, src, cost = () => 1) {
+    this.graph = graph;
+    const numV = graph.numVertices();
+    this.edges = new Uint32Array(numV);
+    this.dist = new Float32Array(numV);
+    this.marked = new BitField(numV);
+    this.search(src, cost);
+  }
+  search(id, cost) {
+    const queue = new DCons();
+    queue.prepend(id);
+    const { dist, edges, graph, marked } = this;
+    dist.fill(4294967295);
+    dist[id] = 0;
+    marked.setAt(id);
+    while (queue.length) {
+      const v = queue.drop();
+      for (let n of graph.neighbors(v)) {
+        const c = dist[v] + cost(v, n);
+        if (c < dist[n] || !marked.at(n)) {
+          edges[n] = v;
+          dist[n] = c;
+          marked.setAt(n);
+          queue.push(n);
         }
+      }
     }
-    hasPathTo(id) {
-        return this.marked.at(id) !== 0;
-    }
-    pathTo(id) {
-        if (!this.marked.at(id))
-            return;
-        const { dist, edges } = this;
-        const path = new DCons();
-        for (; dist[id] > 0; id = edges[id]) {
-            path.prepend(id);
-        }
-        path.prepend(id);
-        return path;
+  }
+  hasPathTo(id) {
+    return this.marked.at(id) !== 0;
+  }
+  pathTo(id) {
+    if (!this.marked.at(id))
+      return;
+    const { dist, edges } = this;
+    const path = new DCons();
+    for (; dist[id] > 0; id = edges[id]) {
+      path.prepend(id);
     }
+    path.prepend(id);
+    return path;
+  }
 }
-/**
- * One-off Breadth-First / shortest path search between `src` and `dest` in
- * `graph`, with optional `cost` function. If successful, returns path as
- * iterable or undefined if no path connects the given vertices.
- *
- * @remarks
- * For repeated queries starting from the same `src` vertex, it's much better &
- * faster to create an {@link BFS} instance to re-use internal state and use
- * {@link BFS.pathTo} to check/obtain paths.
- *
- * By default all edges have an uniform cost, i.e. the overall path cost is
- * topological distance.
- *
- * Reference:
- * - https://en.wikipedia.org/wiki/Breadth-first_search
- * - https://algs4.cs.princeton.edu/40graphs/
- *
- * @param graph -
- * @param src -
- * @param dest -
- * @param cost -
- */
-export const bfs = (graph, src, dest, cost) => new BFS(graph, src, cost).pathTo(dest);
+const bfs = (graph, src, dest, cost) => new BFS(graph, src, cost).pathTo(dest);
+export {
+  BFS,
+  bfs
+};

package/binary.js

@@ -1,111 +1,101 @@
 import { BitMatrix } from "@thi.ng/bitfield/bitmatrix";
 import { __into, __invert, __toDot } from "./utils.js";
-/**
- * Adjacency matrix representation for both directed and undirected graphs and
- * using a compact bit matrix to store edges. Each edge requires only 1 bit
- * in directed graphs or 2 bits in undirected graphs. E.g. this is allows
- * storing 16384 directed edges in just 2KB of memory (128 * 128 / 8 = 2048).
- */
-export class AdjacencyBitMatrix {
-    mat;
-    undirected;
-    numE;
-    constructor(n, edges, undirected = false) {
-        this.mat = new BitMatrix(n);
-        this.undirected = undirected;
-        this.numE = 0;
-        edges && __into(this, edges);
-    }
-    *edges() {
-        const directed = !this.undirected;
-        for (let i = this.mat.m; i-- > 0;) {
-            for (let n of this.neighbors(i)) {
-                if (directed || n > i) {
-                    yield [i, n];
-                }
-            }
-        }
-    }
-    numEdges() {
-        return this.numE;
-    }
-    numVertices() {
-        return this.mat.m;
-    }
-    /**
-     * Resizes matrix to new size given.
-     *
-     * @param n - new max vertices
-     */
-    resize(n) {
-        this.mat.resize(n);
-        return this;
-    }
-    addEdge(from, to) {
-        if (!this.mat.setAt(from, to, true)) {
-            this.numE++;
-            this.undirected && this.mat.setAt(to, from, true);
-            return true;
-        }
-        return false;
-    }
-    removeEdge(from, to) {
-        if (this.mat.setAt(from, to, false)) {
-            this.numE--;
-            this.undirected && this.mat.setAt(to, from, false);
-            return true;
-        }
-        return false;
-    }
-    hasEdge(from, to) {
-        return this.mat.at(from, to) !== 0;
-    }
-    hasVertex(id) {
-        return (this.mat.popCountRow(id) !== 0 || this.mat.popCountColumn(id) !== 0);
-    }
-    degree(id, type = "out") {
-        let degree = 0;
-        if (this.undirected || type !== "in")
-            degree += this.mat.popCountRow(id);
-        if (!this.undirected && type !== "out")
-            degree += this.mat.popCountColumn(id);
-        return degree;
-    }
-    neighbors(id) {
-        return [...this.mat.row(id, true).positions()];
-    }
-    similarity(id, threshold = 0) {
-        const mat = this.mat;
-        const query = mat.row(id, true);
-        const acc = [];
-        for (let i = 0, m = mat.m; i < m; i++) {
-            if (i === id)
-                continue;
-            const sim = query.similarity(mat.row(i, true));
-            if (sim >= threshold)
-                acc.push([i, sim]);
+class AdjacencyBitMatrix {
+  mat;
+  undirected;
+  numE;
+  constructor(n, edges, undirected = false) {
+    this.mat = new BitMatrix(n);
+    this.undirected = undirected;
+    this.numE = 0;
+    edges && __into(this, edges);
+  }
+  *edges() {
+    const directed = !this.undirected;
+    for (let i = this.mat.m; i-- > 0; ) {
+      for (let n of this.neighbors(i)) {
+        if (directed || n > i) {
+          yield [i, n];
         }
-        return acc.sort((a, b) => b[1] - a[1]);
+      }
     }
-    invert() {
-        return __invert(new AdjacencyBitMatrix(this.mat.n, undefined, this.undirected), this.edges());
+  }
+  numEdges() {
+    return this.numE;
+  }
+  numVertices() {
+    return this.mat.m;
+  }
+  /**
+   * Resizes matrix to new size given.
+   *
+   * @param n - new max vertices
+   */
+  resize(n) {
+    this.mat.resize(n);
+    return this;
+  }
+  addEdge(from, to) {
+    if (!this.mat.setAt(from, to, true)) {
+      this.numE++;
+      this.undirected && this.mat.setAt(to, from, true);
+      return true;
     }
-    toString() {
-        return this.mat.toString();
+    return false;
+  }
+  removeEdge(from, to) {
+    if (this.mat.setAt(from, to, false)) {
+      this.numE--;
+      this.undirected && this.mat.setAt(to, from, false);
+      return true;
     }
-    toDot(ids) {
-        return __toDot(this.edges(), this.undirected, ids);
+    return false;
+  }
+  hasEdge(from, to) {
+    return this.mat.at(from, to) !== 0;
+  }
+  hasVertex(id) {
+    return this.mat.popCountRow(id) !== 0 || this.mat.popCountColumn(id) !== 0;
+  }
+  degree(id, type = "out") {
+    let degree = 0;
+    if (this.undirected || type !== "in")
+      degree += this.mat.popCountRow(id);
+    if (!this.undirected && type !== "out")
+      degree += this.mat.popCountColumn(id);
+    return degree;
+  }
+  neighbors(id) {
+    return [...this.mat.row(id, true).positions()];
+  }
+  similarity(id, threshold = 0) {
+    const mat = this.mat;
+    const query = mat.row(id, true);
+    const acc = [];
+    for (let i = 0, m = mat.m; i < m; i++) {
+      if (i === id)
+        continue;
+      const sim = query.similarity(mat.row(i, true));
+      if (sim >= threshold)
+        acc.push([i, sim]);
     }
+    return acc.sort((a, b) => b[1] - a[1]);
+  }
+  invert() {
+    return __invert(
+      new AdjacencyBitMatrix(this.mat.n, void 0, this.undirected),
+      this.edges()
+    );
+  }
+  toString() {
+    return this.mat.toString();
+  }
+  toDot(ids) {
+    return __toDot(this.edges(), this.undirected, ids);
+  }
 }
-/**
- * Creates adjacency matrix backed by a
- * [`BitMatrix`](https://docs.thi.ng/umbrella/bitfield/classes/BitMatrix.html)
- * with capacity `n` (max vertices), optionally initialized with given edge
- * pairs. Each edge is `[src-node dest-node]`. If `undirected` is true (default:
- * false), creates symmetrical adjacencies.
- *
- * @param n - max vertices
- * @param edges - edge pairs
- * @param undirected -true, if undirected
- */
-export const defAdjBitMatrix = (n, edges, undirected) => new AdjacencyBitMatrix(n, edges, undirected);
+const defAdjBitMatrix = (n, edges, undirected) => new AdjacencyBitMatrix(n, edges, undirected);
+export {
+  AdjacencyBitMatrix,
+  defAdjBitMatrix
+};

package/dfs.js

@@ -1,50 +1,45 @@
 import { BitField } from "@thi.ng/bitfield/bitfield";
 import { DCons } from "@thi.ng/dcons/dcons";
-export class DFS {
-    graph;
-    marked;
-    edges;
-    src;
-    constructor(graph, src) {
-        this.graph = graph;
-        this.src = src;
-        const numV = graph.numVertices();
-        this.edges = new Uint32Array(numV);
-        this.marked = new BitField(numV);
-        this.search(src);
+class DFS {
+  graph;
+  marked;
+  edges;
+  src;
+  constructor(graph, src) {
+    this.graph = graph;
+    this.src = src;
+    const numV = graph.numVertices();
+    this.edges = new Uint32Array(numV);
+    this.marked = new BitField(numV);
+    this.search(src);
+  }
+  search(id) {
+    const { edges, marked } = this;
+    marked.setAt(id);
+    for (let n of this.graph.neighbors(id)) {
+      if (!marked.at(n)) {
+        edges[n] = id;
+        this.search(n);
+      }
     }
-    search(id) {
-        const { edges, marked } = this;
-        marked.setAt(id);
-        for (let n of this.graph.neighbors(id)) {
-            if (!marked.at(n)) {
-                edges[n] = id;
-                this.search(n);
-            }
-        }
-    }
-    hasPathTo(id) {
-        return this.marked.at(id) !== 0;
-    }
-    pathTo(id) {
-        if (!this.marked.at(id))
-            return;
-        const { edges, src } = this;
-        const path = new DCons();
-        for (; id !== src; id = edges[id]) {
-            path.prepend(id);
-        }
-        path.prepend(id);
-        return path;
+  }
+  hasPathTo(id) {
+    return this.marked.at(id) !== 0;
+  }
+  pathTo(id) {
+    if (!this.marked.at(id))
+      return;
+    const { edges, src } = this;
+    const path = new DCons();
+    for (; id !== src; id = edges[id]) {
+      path.prepend(id);
     }
+    path.prepend(id);
+    return path;
+  }
 }
-/**
- * One-off Depth-First path search from vertex `src` to `dest` in given `graph`.
- * If successful, returns path as iterable or undefined if no path connects the
- * given vertices.
- *
- * @param graph -
- * @param src -
- * @param dest -
- */
-export const dfs = (graph, src, dest) => new DFS(graph, src).pathTo(dest);
+const dfs = (graph, src, dest) => new DFS(graph, src).pathTo(dest);
+export {
+  DFS,
+  dfs
+};

package/disjoint-set.js

@@ -1,101 +1,91 @@
 import { fillRange } from "@thi.ng/arrays/fill-range";
-/**
- * Typed array based Disjoint Set implementation with quick union and path
- * compression, after Sedgewick & Wayne.
- *
- * @remarks
- * - https://en.wikipedia.org/wiki/Disjoint-set_data_structure
- * - https://algs4.cs.princeton.edu/lectures/15UnionFind-2x2.pdf
- */
-export class DisjointSet {
-    roots;
-    ranks;
-    count;
-    /**
-     * Creates new instance with `n` initial singular subsets.
-     *
-     * @param n - initial capacity, ID range [0..n)
-     */
-    constructor(n) {
-        this.roots = fillRange(new Uint32Array(n));
-        this.ranks = new Uint8Array(n);
-        this.count = n;
+class DisjointSet {
+  roots;
+  ranks;
+  count;
+  /**
+   * Creates new instance with `n` initial singular subsets.
+   *
+   * @param n - initial capacity, ID range [0..n)
+   */
+  constructor(n) {
+    this.roots = fillRange(new Uint32Array(n));
+    this.ranks = new Uint8Array(n);
+    this.count = n;
+  }
+  /**
+   * Returns canonical ID (tree root) for given `id`. Unless `id`
+   * already is unified with some other ID, this will always return
+   * `id` itself (since each node is initially its own root).
+   *
+   * @param id - node ID
+   */
+  canonical(id) {
+    const roots = this.roots;
+    while (id !== roots[id]) {
+      id = roots[id] = roots[roots[id]];
     }
-    /**
-     * Returns canonical ID (tree root) for given `id`. Unless `id`
-     * already is unified with some other ID, this will always return
-     * `id` itself (since each node is initially its own root).
-     *
-     * @param id - node ID
-     */
-    canonical(id) {
-        const roots = this.roots;
-        while (id !== roots[id]) {
-            id = roots[id] = roots[roots[id]];
-        }
-        return id;
+    return id;
+  }
+  /**
+   * Connects combines the trees of the given two node IDs and returns
+   * the new resulting canonical tree root ID.
+   *
+   * @param a - node ID
+   * @param b - node ID
+   */
+  union(a, b) {
+    const rootA = this.canonical(a);
+    const rootB = this.canonical(b);
+    if (rootA === rootB) {
+      return rootA;
     }
-    /**
-     * Connects combines the trees of the given two node IDs and returns
-     * the new resulting canonical tree root ID.
-     *
-     * @param a - node ID
-     * @param b - node ID
-     */
-    union(a, b) {
-        const rootA = this.canonical(a);
-        const rootB = this.canonical(b);
-        if (rootA === rootB) {
-            return rootA;
-        }
-        this.count--;
-        const ranks = this.ranks;
-        const ra = ranks[rootA];
-        const rb = ranks[rootB];
-        if (ra < rb) {
-            return (this.roots[rootA] = rootB);
-        }
-        ra === rb && ranks[rootA]++;
-        return (this.roots[rootB] = rootA);
+    this.count--;
+    const ranks = this.ranks;
+    const ra = ranks[rootA];
+    const rb = ranks[rootB];
+    if (ra < rb) {
+      return this.roots[rootA] = rootB;
     }
-    /**
-     * Returns true, if the given two nodes belong to the same tree /
-     * subset.
-     *
-     * @param a - node ID
-     * @param b - node ID
-     */
-    unified(a, b) {
-        return this.canonical(a) === this.canonical(b);
-    }
-    /**
-     * Returns a `Map` of all subsets (connected components) with their
-     * canonical tree root IDs as keys and arrays of node IDs as values.
-     *
-     * @remarks
-     * If only the number of subsets is required, use the `count`
-     * property of this class instance instead (O(1), updated with each
-     * call to {@link DisjointSet.union}).
-     */
-    subsets() {
-        const sets = new Map();
-        const roots = this.roots;
-        for (let i = roots.length; i-- > 0;) {
-            const id = this.canonical(i);
-            const s = sets.get(id);
-            if (s) {
-                s.push(i);
-            }
-            else {
-                sets.set(id, [i]);
-            }
-        }
-        return sets;
+    ra === rb && ranks[rootA]++;
+    return this.roots[rootB] = rootA;
+  }
+  /**
+   * Returns true, if the given two nodes belong to the same tree /
+   * subset.
+   *
+   * @param a - node ID
+   * @param b - node ID
+   */
+  unified(a, b) {
+    return this.canonical(a) === this.canonical(b);
+  }
+  /**
+   * Returns a `Map` of all subsets (connected components) with their
+   * canonical tree root IDs as keys and arrays of node IDs as values.
+   *
+   * @remarks
+   * If only the number of subsets is required, use the `count`
+   * property of this class instance instead (O(1), updated with each
+   * call to {@link DisjointSet.union}).
+   */
+  subsets() {
+    const sets = /* @__PURE__ */ new Map();
+    const roots = this.roots;
+    for (let i = roots.length; i-- > 0; ) {
+      const id = this.canonical(i);
+      const s = sets.get(id);
+      if (s) {
+        s.push(i);
+      } else {
+        sets.set(id, [i]);
+      }
     }
+    return sets;
+  }
 }
-/**
- * Creates a new {@link DisjointSet} with capacity `n`.
- *
- * @param n -
- */
-export const defDisjointSet = (n) => new DisjointSet(n);
+const defDisjointSet = (n) => new DisjointSet(n);
+export {
+  DisjointSet,
+  defDisjointSet
+};