theprogrammablemind 7.5.7 → 7.5.8

package/package.json

@@ -44,6 +44,7 @@
     "src/config.js",
     "src/copy.js",
     "src/digraph.js",
+    "src/digraph_internal.js",
     "src/generators.js",
     "src/semantics.js"
   ],
@@ -62,6 +63,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.5.7",
+  "version": "7.5.8",
   "license": "ISC"
 }

package/src/digraph_internal.js

@@ -0,0 +1,131 @@
+const toA = (edge) => {
+  if (Array.isArray(edge)) {
+    return edge
+  } else {
+    return [edge.child, edge.parent]
+  }
+}
+
+class DigraphInternal {
+  // edges maybe either [child, parent] or { child, parent }
+  constructor (edges = []) {
+    // dont make a copy of edges. this is shared and that breaks stuff. TODO fix this
+    this._edges = edges
+  }
+
+  addEdges(edges) {
+    for (let edge of edges) {
+      this.addEdge(edge)
+    }
+  }
+
+  addEdge(edge) {
+    edge = toA(edge)
+    this._edges.push(edge)
+  }
+
+  get edges() {
+    return this._edges
+  }
+
+  set edges(edges) {
+    this._edges = edges
+  }
+
+/*
+  set edges(edges) {
+    this._edges = edges.map( toA )
+  }
+*/
+
+  acdcs (s, from, to) {
+    const todo = [s]
+    const seen = new Set([s])
+    const acdcs = new Set([])
+    while (todo.length > 0) {
+      const n = todo.pop()
+      this._edges.forEach((e) => {
+        e = toA(e)
+        if (e[from] === n) {
+          acdcs.add(e[to])
+          if (!seen.has(e[to])) {
+            todo.push(e[to])
+            seen.add(e[to])
+          }
+        }
+      })
+    }
+    return acdcs
+  }
+
+  isA (low, high) {
+    if (low === high) {
+      return true
+    }
+    return this.ancestors(low).has(high)
+  }
+
+  lessThan (low, high) {
+    if (low === high) {
+      return false
+    }
+    return this.ancestors(low).has(high)
+  }
+
+  descendants (s) {
+    return this.acdcs(s, 1, 0)
+  }
+
+  ancestors (s) {
+    return this.acdcs(s, 0, 1)
+  }
+
+  minima (nodes) {
+    let minima = new Set(nodes)
+    const ancestors = new Set([])
+    nodes.forEach((node) => {
+      this.ancestors(node).forEach((n) => ancestors.add(n))
+    })
+    ancestors.forEach((n) => minima.delete(n))
+    if (minima.size === 0) {
+      // all unrelated
+      minima = new Set(nodes)
+    }
+    return minima
+  }
+
+  maxima (nodes) {
+    const maxima = new Set(nodes)
+    const descendants = new Set([])
+    nodes.forEach((node) => {
+      this.descendants(node).forEach((n) => descendants.add(n))
+    })
+    descendants.forEach((n) => maxima.delete(n))
+    return maxima
+  }
+
+  add (child, parent) {
+    this._edges.push([child, parent])
+  }
+
+  addList (l) {
+    for (let i = 1; i < l.length; ++i) {
+      this._edges.push([l[i - 1], l[i]])
+    }
+  }
+
+  order (todo) {
+    const ordered = []
+    while (todo.length > 0) {
+      const nodes = this.minima(todo)
+      todo = todo.filter((e) => !nodes.has(e))
+      for (const node of nodes) {
+        ordered.push(node)
+      }
+      // ordered = ordered.concat([...nodes])
+    }
+    return ordered
+  }
+}
+
+module.exports = DigraphInternal