@thi.ng/adjacency 2.1.12 → 2.2.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2022-06-09T16:14:01Z
+- **Last updated**: 2022-07-19T15:36:12Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,19 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [2.2.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/adjacency@2.2.0) (2022-07-19)
+
+#### 🚀 Features
+
+- update AdjacencyList ([5d85d87](https://github.com/thi-ng/umbrella/commit/5d85d87))
+  - add vertices() iterator
+  - rename old `.vertices` field => `.adjacency`
+  - add adjListFromAdjacency() factory fn
+
+#### ♻️ Refactoring
+
+- update DCons call sites ([2dfec21](https://github.com/thi-ng/umbrella/commit/2dfec21))
+
 ## [2.1.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/adjacency@2.1.0) (2021-11-17)
 
 #### 🚀 Features

package/bfs.js

@@ -10,7 +10,8 @@ export class BFS {
         this.search(src, cost);
     }
     search(id, cost) {
-        const queue = new DCons().cons(id);
+        const queue = new DCons();
+        queue.prepend(id);
         const { dist, edges, graph, marked } = this;
         dist.fill(0xffffffff);
         dist[id] = 0;
@@ -37,9 +38,9 @@ export class BFS {
         const { dist, edges } = this;
         const path = new DCons();
         for (; dist[id] > 0; id = edges[id]) {
-            path.cons(id);
+            path.prepend(id);
         }
-        path.cons(id);
+        path.prepend(id);
         return path;
     }
 }

package/binary.js

@@ -1,5 +1,5 @@
 import { BitMatrix } from "@thi.ng/bitfield/bitmatrix";
-import { into, invert, toDot } from "./utils.js";
+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
@@ -11,7 +11,7 @@ export class AdjacencyBitMatrix {
         this.mat = new BitMatrix(n);
         this.undirected = undirected;
         this.numE = 0;
-        edges && into(this, edges);
+        edges && __into(this, edges);
     }
     *edges() {
         const directed = !this.undirected;
@@ -80,13 +80,13 @@ export class AdjacencyBitMatrix {
         return res;
     }
     invert() {
-        return invert(new AdjacencyBitMatrix(this.mat.n, undefined, this.undirected), this.edges());
+        return __invert(new AdjacencyBitMatrix(this.mat.n, undefined, this.undirected), this.edges());
     }
     toString() {
         return this.mat.toString();
     }
     toDot(ids) {
-        return toDot(this.edges(), this.undirected, ids);
+        return __toDot(this.edges(), this.undirected, ids);
     }
 }
 /**

package/dfs.js

@@ -28,9 +28,9 @@ export class DFS {
         const { edges, src } = this;
         const path = new DCons();
         for (; id !== src; id = edges[id]) {
-            path.cons(id);
+            path.prepend(id);
         }
-        path.cons(id);
+        path.prepend(id);
         return path;
     }
 }

package/list.d.ts

@@ -1,13 +1,14 @@
-import { DCons } from "@thi.ng/dcons/dcons";
+import type { Nullable } from "@thi.ng/api";
 import type { DegreeType, Edge, IGraph } from "./api.js";
 export declare class AdjacencyList implements IGraph<number> {
-    vertices: DCons<number>[];
+    adjacency: number[][];
     indegree: number[];
     protected numE: number;
     protected numV: number;
     constructor(edges?: Iterable<Edge>);
     numEdges(): number;
     numVertices(): number;
+    vertices(): Generator<number, void, unknown>;
     edges(): Generator<Edge<number>, void, unknown>;
     addVertex(id: number): void;
     removeVertex(id: number): boolean;
@@ -17,9 +18,10 @@ export declare class AdjacencyList implements IGraph<number> {
     degree(id: number, type?: DegreeType): number;
     neighbors(id: number): Iterable<number>;
     invert(): AdjacencyList;
-    toString(): string;
     toDot(ids?: string[]): string;
-    protected ensureVertexData(id: number): DCons<number>;
+    toString(): string;
+    protected ensureVertexData(id: number): number[];
 }
 export declare const defAdjList: (edges?: Iterable<Edge>) => AdjacencyList;
+export declare const adjListFromAdjacency: (src: Nullable<number[]>[]) => AdjacencyList;
 //# sourceMappingURL=list.d.ts.map

package/list.js

@@ -1,12 +1,11 @@
-import { DCons } from "@thi.ng/dcons/dcons";
-import { into, invert, toDot } from "./utils.js";
+import { __into, __invert, __toDot } from "./utils.js";
 export class AdjacencyList {
     constructor(edges) {
-        this.vertices = [];
+        this.adjacency = [];
         this.indegree = [];
         this.numE = 0;
         this.numV = 0;
-        edges && into(this, edges);
+        edges && __into(this, edges);
     }
     numEdges() {
         return this.numE;
@@ -14,10 +13,17 @@ export class AdjacencyList {
     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 vertices = this.vertices;
-        for (let i = 0, n = vertices.length; i < n; i++) {
-            const vertex = vertices[i];
+        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)
@@ -28,24 +34,22 @@ export class AdjacencyList {
         this.ensureVertexData(id);
     }
     removeVertex(id) {
-        const { vertices, indegree } = this;
-        const vertex = vertices[id];
+        const { adjacency, indegree } = this;
+        const vertex = adjacency[id];
         if (!vertex)
             return false;
         // remove outgoing
         while (vertex.length) {
-            const to = vertex.first();
-            vertex.drop();
-            indegree[to]--;
+            indegree[vertex.pop()]--;
             this.numE--;
         }
-        delete vertices[id];
+        delete adjacency[id];
         // remove incoming
-        for (let i = 0, n = vertices.length; i < n && indegree[id] > 0; i++) {
-            const vertex = this.vertices[i];
+        for (let i = 0, n = adjacency.length; i < n && indegree[id] > 0; i++) {
+            const vertex = adjacency[i];
             if (!vertex)
                 continue;
-            while (!!vertex.find(id))
+            while (vertex.includes(id))
                 this.removeEdge(i, id);
         }
         this.numV--;
@@ -60,11 +64,11 @@ export class AdjacencyList {
         return true;
     }
     removeEdge(from, to) {
-        const vertex = this.vertices[from];
+        const vertex = this.adjacency[from];
         if (vertex) {
-            const dest = vertex.find(to);
-            if (dest) {
-                vertex.remove(dest);
+            const dest = vertex.indexOf(to);
+            if (dest >= 0) {
+                vertex.splice(dest, 1);
                 this.numE--;
                 this.indegree[to]--;
                 return true;
@@ -73,12 +77,12 @@ export class AdjacencyList {
         return false;
     }
     hasEdge(from, to) {
-        const vertex = this.vertices[from];
-        return vertex ? !!vertex.find(to) : false;
+        const vertex = this.adjacency[from];
+        return vertex ? vertex.includes(to) : false;
     }
     degree(id, type = "out") {
         let degree = 0;
-        const vertex = this.vertices[id];
+        const vertex = this.adjacency[id];
         if (vertex) {
             if (type !== "in")
                 degree += vertex.length;
@@ -88,33 +92,44 @@ export class AdjacencyList {
         return degree;
     }
     neighbors(id) {
-        return [...(this.vertices[id] || [])];
+        return [...(this.adjacency[id] || [])];
     }
     invert() {
-        return invert(new AdjacencyList(), this.edges());
+        return __invert(new AdjacencyList(), this.edges());
+    }
+    toDot(ids) {
+        return __toDot(this.edges(), false, ids);
     }
     toString() {
-        const vertices = this.vertices;
+        const { adjacency } = this;
         const res = [];
-        for (let i = 0, n = vertices.length; i < n; i++) {
-            if (vertices[i]) {
-                res.push(`${i}: [${[...vertices[i]]
+        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");
     }
-    toDot(ids) {
-        return toDot(this.edges(), false, ids);
-    }
     ensureVertexData(id) {
-        const vertex = this.vertices[id];
+        const vertex = this.adjacency[id];
         if (vertex)
             return vertex;
         this.numV++;
         this.indegree[id] = 0;
-        return (this.vertices[id] = new DCons());
+        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;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/adjacency",
-  "version": "2.1.12",
+  "version": "2.2.0",
   "description": "Sparse & bitwise adjacency matrices and related functions for directed & undirected graphs",
   "type": "module",
   "module": "./index.js",
@@ -34,21 +34,21 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.3.7",
-    "@thi.ng/arrays": "^2.3.0",
-    "@thi.ng/bitfield": "^2.1.8",
-    "@thi.ng/dcons": "^3.2.6",
-    "@thi.ng/errors": "^2.1.7",
-    "@thi.ng/sparse": "^0.3.11"
+    "@thi.ng/api": "^8.3.8",
+    "@thi.ng/arrays": "^2.3.1",
+    "@thi.ng/bitfield": "^2.2.0",
+    "@thi.ng/dcons": "^3.2.7",
+    "@thi.ng/errors": "^2.1.8",
+    "@thi.ng/sparse": "^0.3.12"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.25.0",
-    "@thi.ng/testament": "^0.2.8",
-    "@thi.ng/vectors": "^7.5.7",
+    "@thi.ng/testament": "^0.2.9",
+    "@thi.ng/vectors": "^7.5.8",
     "rimraf": "^3.0.2",
     "tools": "^0.0.1",
     "typedoc": "^0.22.17",
-    "typescript": "^4.7.3"
+    "typescript": "^4.7.4"
   },
   "keywords": [
     "adjacency",
@@ -119,5 +119,5 @@
     ],
     "year": 2018
   },
-  "gitHead": "e64b1ab39ae9bcc494ef006f6329e5182fa2a326\n"
+  "gitHead": "108a6357b77d457912d30681d7cc5603ae995209\n"
 }

package/sparse.js

@@ -1,6 +1,6 @@
 import { ensureIndex2 } from "@thi.ng/errors/out-of-bounds";
 import { CSR } from "@thi.ng/sparse/csr";
-import { into, invert, toDot } from "./utils.js";
+import { __into, __invert, __toDot } from "./utils.js";
 export class AdjacencyMatrix extends CSR {
     constructor(n, data, rows, cols, undirected = false) {
         super(n, n, data, rows, cols);
@@ -58,7 +58,7 @@ export class AdjacencyMatrix extends CSR {
         return this.nzRowCols(id);
     }
     invert() {
-        return invert(defAdjMatrix(this.m, undefined, this.undirected), this.edges());
+        return __invert(defAdjMatrix(this.m, undefined, this.undirected), this.edges());
     }
     /**
      * Returns a diagonal sparse matrix {@link @thi.ng/sparse#CSR} containing
@@ -140,7 +140,7 @@ export class AdjacencyMatrix extends CSR {
             .add(deg.sub(I).mulN(n * n));
     }
     toDot(ids) {
-        return toDot(this.edges(), this.undirected, ids);
+        return __toDot(this.edges(), this.undirected, ids);
     }
 }
 /**
@@ -156,6 +156,6 @@ export class AdjacencyMatrix extends CSR {
 export const defAdjMatrix = (n, edges, undirected = false) => {
     const raw = CSR.empty(n);
     const mat = new AdjacencyMatrix(n, raw.data, raw.rows, raw.cols, undirected);
-    edges && into(mat, edges);
+    edges && __into(mat, edges);
     return mat;
 };

package/utils.d.ts

@@ -1,9 +1,9 @@
 import type { Pair } from "@thi.ng/api";
 import type { Edge, IGraph } from "./api.js";
 /** @internal */
-export declare const toDot: (edges: Iterable<Pair<number, number>>, undirected: boolean, ids?: string[]) => string;
+export declare const __toDot: (edges: Iterable<Pair<number, number>>, undirected: boolean, ids?: string[]) => string;
 /** @internal */
-export declare const into: (graph: IGraph, edges: Iterable<Edge>) => void;
+export declare const __into: (graph: IGraph, edges: Iterable<Edge>) => void;
 /** @internal */
-export declare const invert: <T extends IGraph<number>>(graph: T, edges: Iterable<Edge>) => T;
+export declare const __invert: <T extends IGraph<number>>(graph: T, edges: Iterable<Edge>) => T;
 //# sourceMappingURL=utils.d.ts.map

package/utils.js

@@ -1,5 +1,5 @@
 /** @internal */
-export const toDot = (edges, undirected, ids) => {
+export const __toDot = (edges, undirected, ids) => {
     const [type, sep] = undirected ? ["graph", "--"] : ["digraph", "->"];
     const res = [`${type} g {`];
     for (let e of edges) {
@@ -11,13 +11,13 @@ export const toDot = (edges, undirected, ids) => {
     return res.join("\n");
 };
 /** @internal */
-export const into = (graph, edges) => {
+export const __into = (graph, edges) => {
     for (let e of edges) {
         graph.addEdge(e[0], e[1]);
     }
 };
 /** @internal */
-export const invert = (graph, edges) => {
+export const __invert = (graph, edges) => {
     for (let e of edges) {
         graph.addEdge(e[1], e[0]);
     }