@statewalker/fsm-charts 0.0.1

package/src/graphlib/alg/dfs.js

@@ -0,0 +1,46 @@
+import { _ } from '../../lodash-es/index.ts';
+
+export { dfs };
+
+/*
+ * A helper that preforms a pre- or post-order traversal on the input graph
+ * and returns the nodes in the order they were visited. If the graph is
+ * undirected then this algorithm will navigate using neighbors. If the graph
+ * is directed then this algorithm will navigate using successors.
+ *
+ * Order must be one of "pre" or "post".
+ */
+function dfs(g, vs, order) {
+  if (!_.isArray(vs)) {
+    vs = [vs];
+  }
+
+  var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);
+
+  var acc = [];
+  var visited = {};
+  _.each(vs, function (v) {
+    if (!g.hasNode(v)) {
+      throw new Error('Graph does not have node: ' + v);
+    }
+
+    doDfs(g, v, order === 'post', visited, navigation, acc);
+  });
+  return acc;
+}
+
+function doDfs(g, v, postorder, visited, navigation, acc) {
+  if (!_.has(visited, v)) {
+    visited[v] = true;
+
+    if (!postorder) {
+      acc.push(v);
+    }
+    _.each(navigation(v), function (w) {
+      doDfs(g, w, postorder, visited, navigation, acc);
+    });
+    if (postorder) {
+      acc.push(v);
+    }
+  }
+}

package/src/graphlib/alg/dijkstra-all.d.ts

@@ -0,0 +1 @@
+export function dijkstraAll(g: any, weightFunc: any, edgeFunc: any): {};

package/src/graphlib/alg/dijkstra-all.js

@@ -0,0 +1,14 @@
+import { _ } from '../../lodash-es/index.ts';
+import { dijkstra } from './dijkstra.js';
+
+export { dijkstraAll };
+
+function dijkstraAll(g, weightFunc, edgeFunc) {
+  return _.transform(
+    g.nodes(),
+    function (acc, v) {
+      acc[v] = dijkstra(g, v, weightFunc, edgeFunc);
+    },
+    {}
+  );
+}

package/src/graphlib/alg/dijkstra.d.ts

@@ -0,0 +1 @@
+export function dijkstra(g: any, source: any, weightFn: any, edgeFn: any): {};

package/src/graphlib/alg/dijkstra.js

@@ -0,0 +1,65 @@
+import { _ } from '../../lodash-es/index.ts';
+import { PriorityQueue } from '../data/priority-queue.js';
+
+export { dijkstra };
+
+var DEFAULT_WEIGHT_FUNC = _.constant(1);
+
+function dijkstra(g, source, weightFn, edgeFn) {
+  return runDijkstra(
+    g,
+    String(source),
+    weightFn || DEFAULT_WEIGHT_FUNC,
+    edgeFn ||
+      function (v) {
+        return g.outEdges(v);
+      }
+  );
+}
+
+function runDijkstra(g, source, weightFn, edgeFn) {
+  var results = {};
+  var pq = new PriorityQueue();
+  var v, vEntry;
+
+  var updateNeighbors = function (edge) {
+    var w = edge.v !== v ? edge.v : edge.w;
+    var wEntry = results[w];
+    var weight = weightFn(edge);
+    var distance = vEntry.distance + weight;
+
+    if (weight < 0) {
+      throw new Error(
+        'dijkstra does not allow negative edge weights. ' +
+          'Bad edge: ' +
+          edge +
+          ' Weight: ' +
+          weight
+      );
+    }
+
+    if (distance < wEntry.distance) {
+      wEntry.distance = distance;
+      wEntry.predecessor = v;
+      pq.decrease(w, distance);
+    }
+  };
+
+  g.nodes().forEach(function (v) {
+    var distance = v === source ? 0 : Number.POSITIVE_INFINITY;
+    results[v] = { distance: distance };
+    pq.add(v, distance);
+  });
+
+  while (pq.size() > 0) {
+    v = pq.removeMin();
+    vEntry = results[v];
+    if (vEntry.distance === Number.POSITIVE_INFINITY) {
+      break;
+    }
+
+    edgeFn(v).forEach(updateNeighbors);
+  }
+
+  return results;
+}

package/src/graphlib/alg/find-cycles.d.ts

@@ -0,0 +1 @@
+export function findCycles(g: any): any[];

package/src/graphlib/alg/find-cycles.js

@@ -0,0 +1,10 @@
+import { _ } from '../../lodash-es/index.ts';
+import { tarjan } from './tarjan.js';
+
+export { findCycles };
+
+function findCycles(g) {
+  return _.filter(tarjan(g), function (cmpt) {
+    return cmpt.length > 1 || (cmpt.length === 1 && g.hasEdge(cmpt[0], cmpt[0]));
+  });
+}

package/src/graphlib/alg/floyd-warshall.d.ts

@@ -0,0 +1 @@
+export function floydWarshall(g: any, weightFn: any, edgeFn: any): {};

package/src/graphlib/alg/floyd-warshall.js

@@ -0,0 +1,55 @@
+import { _ } from '../../lodash-es/index.ts';
+
+export { floydWarshall };
+
+var DEFAULT_WEIGHT_FUNC = _.constant(1);
+
+function floydWarshall(g, weightFn, edgeFn) {
+  return runFloydWarshall(
+    g,
+    weightFn || DEFAULT_WEIGHT_FUNC,
+    edgeFn ||
+      function (v) {
+        return g.outEdges(v);
+      }
+  );
+}
+
+function runFloydWarshall(g, weightFn, edgeFn) {
+  var results = {};
+  var nodes = g.nodes();
+
+  nodes.forEach(function (v) {
+    results[v] = {};
+    results[v][v] = { distance: 0 };
+    nodes.forEach(function (w) {
+      if (v !== w) {
+        results[v][w] = { distance: Number.POSITIVE_INFINITY };
+      }
+    });
+    edgeFn(v).forEach(function (edge) {
+      var w = edge.v === v ? edge.w : edge.v;
+      var d = weightFn(edge);
+      results[v][w] = { distance: d, predecessor: v };
+    });
+  });
+
+  nodes.forEach(function (k) {
+    var rowK = results[k];
+    nodes.forEach(function (i) {
+      var rowI = results[i];
+      nodes.forEach(function (j) {
+        var ik = rowI[k];
+        var kj = rowK[j];
+        var ij = rowI[j];
+        var altDistance = ik.distance + kj.distance;
+        if (altDistance < ij.distance) {
+          ij.distance = altDistance;
+          ij.predecessor = kj.predecessor;
+        }
+      });
+    });
+  });
+
+  return results;
+}

package/src/graphlib/alg/index.d.ts

@@ -0,0 +1,24 @@
+import { components } from './components.js';
+import { dijkstra } from './dijkstra.js';
+import { dijkstraAll } from './dijkstra-all.js';
+import { findCycles } from './find-cycles.js';
+import { floydWarshall } from './floyd-warshall.js';
+import { isAcyclic } from './is-acyclic.js';
+import { postorder } from './postorder.js';
+import { preorder } from './preorder.js';
+import { prim } from './prim.js';
+import { tarjan } from './tarjan.js';
+import { topsort } from './topsort.js';
+export {
+  components,
+  dijkstra,
+  dijkstraAll,
+  findCycles,
+  floydWarshall,
+  isAcyclic,
+  postorder,
+  preorder,
+  prim,
+  tarjan,
+  topsort,
+};

package/src/graphlib/alg/index.js

@@ -0,0 +1,25 @@
+import { components } from './components.js';
+import { dijkstra } from './dijkstra.js';
+import { dijkstraAll } from './dijkstra-all.js';
+import { findCycles } from './find-cycles.js';
+import { floydWarshall } from './floyd-warshall.js';
+import { isAcyclic } from './is-acyclic.js';
+import { postorder } from './postorder.js';
+import { preorder } from './preorder.js';
+import { prim } from './prim.js';
+import { tarjan } from './tarjan.js';
+import { topsort } from './topsort.js';
+
+export {
+  components,
+  dijkstra,
+  dijkstraAll,
+  findCycles,
+  floydWarshall,
+  isAcyclic,
+  postorder,
+  preorder,
+  prim,
+  tarjan,
+  topsort,
+};

package/src/graphlib/alg/is-acyclic.d.ts

@@ -0,0 +1 @@
+export function isAcyclic(g: any): boolean;

package/src/graphlib/alg/is-acyclic.js

@@ -0,0 +1,15 @@
+import { topsort, CycleException } from './topsort.js';
+
+export { isAcyclic };
+
+function isAcyclic(g) {
+  try {
+    topsort(g);
+  } catch (e) {
+    if (e instanceof CycleException) {
+      return false;
+    }
+    throw e;
+  }
+  return true;
+}

package/src/graphlib/alg/postorder.d.ts

@@ -0,0 +1 @@
+export function postorder(g: any, vs: any): any[];

package/src/graphlib/alg/postorder.js

@@ -0,0 +1,7 @@
+import { dfs } from './dfs.js';
+
+export { postorder };
+
+function postorder(g, vs) {
+  return dfs(g, vs, 'post');
+}

package/src/graphlib/alg/preorder.d.ts

@@ -0,0 +1 @@
+export function preorder(g: any, vs: any): any[];

package/src/graphlib/alg/preorder.js

@@ -0,0 +1,7 @@
+import { dfs } from './dfs.js';
+
+export { preorder };
+
+function preorder(g, vs) {
+  return dfs(g, vs, 'pre');
+}

package/src/graphlib/alg/prim.d.ts

@@ -0,0 +1,2 @@
+export function prim(g: any, weightFunc: any): Graph;
+import { Graph } from '../graph.js';

package/src/graphlib/alg/prim.js

@@ -0,0 +1,52 @@
+import { _ } from '../../lodash-es/index.ts';
+import { PriorityQueue } from '../data/priority-queue.js';
+import { Graph } from '../graph.js';
+
+export { prim };
+
+function prim(g, weightFunc) {
+  var result = new Graph();
+  var parents = {};
+  var pq = new PriorityQueue();
+  var v;
+
+  function updateNeighbors(edge) {
+    var w = edge.v === v ? edge.w : edge.v;
+    var pri = pq.priority(w);
+    if (pri !== undefined) {
+      var edgeWeight = weightFunc(edge);
+      if (edgeWeight < pri) {
+        parents[w] = v;
+        pq.decrease(w, edgeWeight);
+      }
+    }
+  }
+
+  if (g.nodeCount() === 0) {
+    return result;
+  }
+
+  _.each(g.nodes(), function (v) {
+    pq.add(v, Number.POSITIVE_INFINITY);
+    result.setNode(v);
+  });
+
+  // Start from an arbitrary node
+  pq.decrease(g.nodes()[0], 0);
+
+  var init = false;
+  while (pq.size() > 0) {
+    v = pq.removeMin();
+    if (_.has(parents, v)) {
+      result.setEdge(v, parents[v]);
+    } else if (init) {
+      throw new Error('Input graph is not connected: ' + g);
+    } else {
+      init = true;
+    }
+
+    g.nodeEdges(v).forEach(updateNeighbors);
+  }
+
+  return result;
+}

package/src/graphlib/alg/tarjan.d.ts

@@ -0,0 +1 @@
+export function tarjan(g: any): any[];

package/src/graphlib/alg/tarjan.js

@@ -0,0 +1,47 @@
+import { _ } from '../../lodash-es/index.ts';
+
+export { tarjan };
+
+function tarjan(g) {
+  var index = 0;
+  var stack = [];
+  var visited = {}; // node id -> { onStack, lowlink, index }
+  var results = [];
+
+  function dfs(v) {
+    var entry = (visited[v] = {
+      onStack: true,
+      lowlink: index,
+      index: index++,
+    });
+    stack.push(v);
+
+    g.successors(v).forEach(function (w) {
+      if (!_.has(visited, w)) {
+        dfs(w);
+        entry.lowlink = Math.min(entry.lowlink, visited[w].lowlink);
+      } else if (visited[w].onStack) {
+        entry.lowlink = Math.min(entry.lowlink, visited[w].index);
+      }
+    });
+
+    if (entry.lowlink === entry.index) {
+      var cmpt = [];
+      var w;
+      do {
+        w = stack.pop();
+        visited[w].onStack = false;
+        cmpt.push(w);
+      } while (v !== w);
+      results.push(cmpt);
+    }
+  }
+
+  g.nodes().forEach(function (v) {
+    if (!_.has(visited, v)) {
+      dfs(v);
+    }
+  });
+
+  return results;
+}

package/src/graphlib/alg/topsort.d.ts

@@ -0,0 +1,5 @@
+export function topsort(g: any): any[];
+export namespace topsort {
+  export { CycleException };
+}
+export function CycleException(): void;

package/src/graphlib/alg/topsort.js

@@ -0,0 +1,36 @@
+import { _ } from '../../lodash-es/index.ts';
+
+export { topsort, CycleException };
+
+topsort.CycleException = CycleException;
+
+function topsort(g) {
+  var visited = {};
+  var stack = {};
+  var results = [];
+
+  function visit(node) {
+    if (_.has(stack, node)) {
+      throw new CycleException();
+    }
+
+    if (!_.has(visited, node)) {
+      stack[node] = true;
+      visited[node] = true;
+      _.each(g.predecessors(node), visit);
+      delete stack[node];
+      results.push(node);
+    }
+  }
+
+  _.each(g.sinks(), visit);
+
+  if (_.size(visited) !== g.nodeCount()) {
+    throw new CycleException();
+  }
+
+  return results;
+}
+
+function CycleException() {}
+CycleException.prototype = new Error(); // must be an instance of Error to pass testing

package/src/graphlib/data/priority-queue.d.ts

@@ -0,0 +1,59 @@
+/**
+ * A min-priority queue data structure. This algorithm is derived from Cormen,
+ * et al., "Introduction to Algorithms". The basic idea of a min-priority
+ * queue is that you can efficiently (in O(1) time) get the smallest key in
+ * the queue. Adding and removing elements takes O(log n) time. A key can
+ * have its priority decreased in O(log n) time.
+ */
+export class PriorityQueue {
+  _arr: any[];
+  _keyIndices: {};
+  /**
+   * Returns the number of elements in the queue. Takes `O(1)` time.
+   */
+  size(): number;
+  /**
+   * Returns the keys that are in the queue. Takes `O(n)` time.
+   */
+  keys(): any[];
+  /**
+   * Returns `true` if **key** is in the queue and `false` if not.
+   */
+  has(key: any): boolean;
+  /**
+   * Returns the priority for **key**. If **key** is not present in the queue
+   * then this function returns `undefined`. Takes `O(1)` time.
+   *
+   * @param {Object} key
+   */
+  priority(key: any): any;
+  /**
+   * Returns the key for the minimum element in this queue. If the queue is
+   * empty this function throws an Error. Takes `O(1)` time.
+   */
+  min(): any;
+  /**
+   * Inserts a new key into the priority queue. If the key already exists in
+   * the queue this function returns `false`; otherwise it will return `true`.
+   * Takes `O(n)` time.
+   *
+   * @param {Object} key the key to add
+   * @param {Number} priority the initial priority for the key
+   */
+  add(key: any, priority: number): boolean;
+  /**
+   * Removes and returns the smallest key in the queue. Takes `O(log n)` time.
+   */
+  removeMin(): any;
+  /**
+   * Decreases the priority for **key** to **priority**. If the new priority is
+   * greater than the previous priority, this function will throw an Error.
+   *
+   * @param {Object} key the key for which to raise priority
+   * @param {Number} priority the new priority for the key
+   */
+  decrease(key: any, priority: number): void;
+  _heapify(i: any): void;
+  _decrease(index: any): void;
+  _swap(i: any, j: any): void;
+}

package/src/graphlib/data/priority-queue.js

@@ -0,0 +1,152 @@
+import { _ } from '../../lodash-es/index.ts';
+
+export { PriorityQueue };
+
+/**
+ * A min-priority queue data structure. This algorithm is derived from Cormen,
+ * et al., "Introduction to Algorithms". The basic idea of a min-priority
+ * queue is that you can efficiently (in O(1) time) get the smallest key in
+ * the queue. Adding and removing elements takes O(log n) time. A key can
+ * have its priority decreased in O(log n) time.
+ */
+class PriorityQueue {
+  constructor() {
+    this._arr = [];
+    this._keyIndices = {};
+  }
+  /**
+   * Returns the number of elements in the queue. Takes `O(1)` time.
+   */
+  size() {
+    return this._arr.length;
+  }
+  /**
+   * Returns the keys that are in the queue. Takes `O(n)` time.
+   */
+  keys() {
+    return this._arr.map(function (x) {
+      return x.key;
+    });
+  }
+  /**
+   * Returns `true` if **key** is in the queue and `false` if not.
+   */
+  has(key) {
+    return _.has(this._keyIndices, key);
+  }
+  /**
+   * Returns the priority for **key**. If **key** is not present in the queue
+   * then this function returns `undefined`. Takes `O(1)` time.
+   *
+   * @param {Object} key
+   */
+  priority(key) {
+    var index = this._keyIndices[key];
+    if (index !== undefined) {
+      return this._arr[index].priority;
+    }
+  }
+  /**
+   * Returns the key for the minimum element in this queue. If the queue is
+   * empty this function throws an Error. Takes `O(1)` time.
+   */
+  min() {
+    if (this.size() === 0) {
+      throw new Error('Queue underflow');
+    }
+    return this._arr[0].key;
+  }
+  /**
+   * Inserts a new key into the priority queue. If the key already exists in
+   * the queue this function returns `false`; otherwise it will return `true`.
+   * Takes `O(n)` time.
+   *
+   * @param {Object} key the key to add
+   * @param {Number} priority the initial priority for the key
+   */
+  add(key, priority) {
+    var keyIndices = this._keyIndices;
+    key = String(key);
+    if (!_.has(keyIndices, key)) {
+      var arr = this._arr;
+      var index = arr.length;
+      keyIndices[key] = index;
+      arr.push({ key: key, priority: priority });
+      this._decrease(index);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Removes and returns the smallest key in the queue. Takes `O(log n)` time.
+   */
+  removeMin() {
+    this._swap(0, this._arr.length - 1);
+    var min = this._arr.pop();
+    delete this._keyIndices[min.key];
+    this._heapify(0);
+    return min.key;
+  }
+  /**
+   * Decreases the priority for **key** to **priority**. If the new priority is
+   * greater than the previous priority, this function will throw an Error.
+   *
+   * @param {Object} key the key for which to raise priority
+   * @param {Number} priority the new priority for the key
+   */
+  decrease(key, priority) {
+    var index = this._keyIndices[key];
+    if (priority > this._arr[index].priority) {
+      throw new Error(
+        'New priority is greater than current priority. ' +
+          'Key: ' +
+          key +
+          ' Old: ' +
+          this._arr[index].priority +
+          ' New: ' +
+          priority
+      );
+    }
+    this._arr[index].priority = priority;
+    this._decrease(index);
+  }
+  _heapify(i) {
+    var arr = this._arr;
+    var l = 2 * i;
+    var r = l + 1;
+    var largest = i;
+    if (l < arr.length) {
+      largest = arr[l].priority < arr[largest].priority ? l : largest;
+      if (r < arr.length) {
+        largest = arr[r].priority < arr[largest].priority ? r : largest;
+      }
+      if (largest !== i) {
+        this._swap(i, largest);
+        this._heapify(largest);
+      }
+    }
+  }
+  _decrease(index) {
+    var arr = this._arr;
+    var priority = arr[index].priority;
+    var parent;
+    while (index !== 0) {
+      parent = index >> 1;
+      if (arr[parent].priority < priority) {
+        break;
+      }
+      this._swap(index, parent);
+      index = parent;
+    }
+  }
+  _swap(i, j) {
+    var arr = this._arr;
+    var keyIndices = this._keyIndices;
+    var origArrI = arr[i];
+    var origArrJ = arr[j];
+    arr[i] = origArrJ;
+    arr[j] = origArrI;
+    keyIndices[origArrJ.key] = i;
+    keyIndices[origArrI.key] = j;
+  }
+}