Diff

src/main/java/blog/bn/DynamicCBN.java

@@ -0,0 +1,37 @@
+/**
+ * 
+ */
+package blog.bn;
+
+import java.util.Iterator;
+
+import blog.common.HashDynamicGraph;
+import blog.sample.TraceParentRecEvalContext;
+import blog.world.PartialWorld;
+
+/**
+ * @author David T
+ * @since Oct 28, 2014
+ * 
+ */
+public class DynamicCBN extends HashDynamicGraph implements CBN {
+  public DynamicCBN(CBN underlying, PartialWorld world) {
+    for (Iterator iter = underlying.nodes().iterator(); iter.hasNext();) {
+      BayesNetVar var = (BayesNetVar) iter.next();
+      Node curNode = new Node(var);
+      addNode(curNode);
+      for (Iterator iter2 = underlying.getParents(var).iterator(); iter2
+          .hasNext();) {
+        BayesNetVar par = (BayesNetVar) iter2.next();
+        Node parNode = new Node(par);
+        addEdge(new Edge(parNode, curNode));
+      }
+      TraceParentRecEvalContext context = new TraceParentRecEvalContext(world);
+      if (var instanceof VarWithDistrib) {
+        ((VarWithDistrib) var).getDistrib(context);
+      } else if (var instanceof DerivedVar) {
+        ((DerivedVar) var).getValue(context);
+      }
+    }
+  }
+}

src/main/java/blog/bn/DynamicCBNDiff.java

@@ -0,0 +1,21 @@
+/**
+ * 
+ */
+package blog.bn;
+
+import blog.common.HashDynamicGraphDiff;
+
+/**
+ * @author David T
+ * @since Oct 28, 2014
+ * 
+ */
+public class DynamicCBNDiff extends HashDynamicGraphDiff implements CBN {
+  public DynamicCBNDiff(DynamicCBN underlying) {
+    super(underlying);
+  }
+
+  public DynamicCBN getUnderlying() {
+    return (DynamicCBN) underlying;
+  }
+}

src/main/java/blog/common/DynamicGraph.java

@@ -0,0 +1,80 @@
+/**
+ * 
+ */
+package blog.common;
+
+import java.util.Set;
+
+import blog.bn.BayesNetVar;
+
+/**
+ * @author David T
+ * @since Oct 16, 2014
+ * 
+ */
+public interface DynamicGraph extends DGraph {
+
+  MultiMap getParentsMap();
+
+  MultiMap getChildrenMap();
+
+  MultiMap getEdgesAppearOnMap();
+
+  MultiMap getNodesRelatedToMap();
+
+  Set getBarrenNodeSet();
+
+  public class Edge {
+    public Edge(Node src, Node dst) {
+      this.src = src;
+      this.dst = dst;
+    }
+
+    public void setSrc(Node src) {
+      this.src = src;
+    }
+
+    public void setDst(Node dst) {
+      this.dst = dst;
+    }
+
+    public Node getSrc() {
+      return src;
+    }
+
+    public Node getDst() {
+      return dst;
+    }
+
+    private Node src, dst;
+  }
+
+  public class Node {
+    public Node(Object var) {
+      this.var = (BayesNetVar) var;
+    }
+
+    public void setNode(Object var) {
+      this.var = (BayesNetVar) var;
+    }
+
+    public BayesNetVar getNode() {
+      return var;
+    }
+
+    public void incOutDegree() {
+      outDegree++;
+    }
+
+    public void decOutDegree() {
+      outDegree--;
+    }
+
+    public boolean isBarren() {
+      return (outDegree == 0);
+    }
+
+    private BayesNetVar var;
+    private int outDegree = 0;
+  }
+}

src/main/java/blog/common/DynamicGraphDiff.java

@@ -0,0 +1,13 @@
+/**
+ * 
+ */
+package blog.common;
+
+/**
+ * @author David T
+ * @since Sep 28, 2014
+ * 
+ */
+public interface DynamicGraphDiff extends DynamicGraph {
+  DynamicGraph getUnderlying();
+}

src/main/java/blog/common/HashDynamicGraph.java

@@ -0,0 +1,157 @@
+/**
+ * 
+ */
+package blog.common;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+/**
+ * @author David T
+ * @since Oct 16, 2014
+ * 
+ */
+public class HashDynamicGraph extends AbstractDGraph implements DynamicGraph,
+    Cloneable {
+
+  public HashDynamicGraph() {
+    nodeSet = new HashSet();
+    parents = new HashMultiMap();
+    children = new HashMultiMap();
+    edgesAppearOn = new HashMultiMap();
+    nodesRelatedTo = new HashMultiMap();
+    barrenNodeSet = new HashSet();
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see blog.common.DGraph#nodes()
+   */
+  @Override
+  public Set nodes() {
+    return Collections.unmodifiableSet(nodeSet);
+  }
+
+  public MultiMap getParentsMap() {
+    return parents;
+  }
+
+  public MultiMap getChildrenMap() {
+    return children;
+  }
+
+  public MultiMap getEdgesAppearOnMap() {
+    return edgesAppearOn;
+  }
+
+  public MultiMap getNodesRelatedToMap() {
+    return nodesRelatedTo;
+  }
+
+  public boolean addNode(Node v) {
+    return nodeSet.add(v);
+  }
+
+  public boolean removeNode(Node v) {
+    if (nodeSet.contains(v)) {
+      for (Iterator iter = ((Set) parents.get(v)).iterator(); iter.hasNext();) {
+        Node curNode = (Node) iter.next();
+        ((Set) children.get(curNode)).remove(v);
+      }
+      for (Iterator iter = ((Set) children.get(v)).iterator(); iter.hasNext();) {
+        Node curNode = (Node) iter.next();
+        ((Set) parents.get(curNode)).remove(v);
+      }
+      parents.remove(v);
+      children.remove(v);
+      if (edgesAppearOn.containsKey(v)) {
+        for (Iterator iter = ((Set) edgesAppearOn.get(v)).iterator(); iter
+            .hasNext();) {
+          Edge curEdge = (Edge) iter.next();
+          ((Set) nodesRelatedTo.get(curEdge)).remove(v);
+        }
+        edgesAppearOn.remove(v);
+      }
+    }
+    return nodeSet.remove(v);
+  }
+
+  public boolean addEdge(Edge e) {
+    if (nodeSet.contains(e.getSrc()) && nodeSet.contains(e.getDst())
+        && !((Set) parents.get(e.getDst())).contains(e.getSrc())) {
+      ((Set) parents.get(e.getDst())).add(e.getSrc());
+      ((Set) children.get(e.getSrc())).add(e.getDst());
+      e.getSrc().incOutDegree();
+      if (!e.getSrc().isBarren()) {
+        barrenNodeSet.remove(e.getSrc());
+      }
+      return true;
+    }
+    return false;
+  }
+
+  public boolean removeEdge(Edge e) {
+    if (nodeSet.contains(e.getSrc()) && nodeSet.contains(e.getDst())
+        && ((Set) children.get(e.getSrc())).contains(e.getDst())) {
+      ((Set) parents.get(e.getDst())).remove(e.getSrc());
+      ((Set) children.get(e.getSrc())).remove(e.getDst());
+      e.getSrc().decOutDegree();
+      if (e.getSrc().isBarren()) {
+        barrenNodeSet.add(e.getSrc());
+      }
+      if (nodesRelatedTo.containsKey(e)) {
+        for (Iterator iter = ((Set) nodesRelatedTo.get(e)).iterator(); iter
+            .hasNext();) {
+          Node curNode = (Node) iter.next();
+          ((Set) edgesAppearOn.get(curNode)).remove(e);
+        }
+        nodesRelatedTo.remove(e);
+      }
+      return true;
+    }
+    return false;
+  }
+
+  public boolean addLabel(Edge e, Node labelNode) {
+    if (!((Set) edgesAppearOn.get(labelNode)).contains(e)) {
+      ((Set) edgesAppearOn.get(labelNode)).add(e);
+      ((Set) nodesRelatedTo.get(e)).add(labelNode);
+      return true;
+    }
+    return false;
+  }
+
+  public Set getBarrenNodeSet() {
+    return barrenNodeSet;
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see blog.common.DGraph#getParents(java.lang.Object)
+   */
+  @Override
+  public Set getParents(Object v) {
+    return Collections.unmodifiableSet((Set) parents.get(v));
+  }
+
+  /*
+   * (non-Javadoc)
+   * 
+   * @see blog.common.DGraph#getChildren(java.lang.Object)
+   */
+  @Override
+  public Set getChildren(Object v) {
+    return Collections.unmodifiableSet((Set) children.get(v));
+  }
+
+  protected Set nodeSet;
+  protected MultiMap parents;
+  protected MultiMap children;
+  protected MultiMap edgesAppearOn;
+  protected MultiMap nodesRelatedTo;
+  protected Set barrenNodeSet;
+}

src/main/java/blog/common/HashDynamicGraphDiff.java

@@ -0,0 +1,34 @@
+/**
+ * 
+ */
+package blog.common;
+
+/**
+ * @author David T
+ * @since Sep 28, 2014
+ * 
+ */
+public class HashDynamicGraphDiff extends HashDynamicGraph implements
+    DynamicGraphDiff, Cloneable {
+
+  public HashDynamicGraphDiff(DynamicGraph underlying) {
+    this.underlying = underlying;
+    this.nodeSet = new HashSetDiff(underlying.nodes());
+    this.parents = new HashMultiMapDiff(underlying.getParentsMap());
+    this.children = new HashMultiMapDiff(underlying.getChildrenMap());
+    this.edgesAppearOn = new HashMultiMapDiff(underlying.getEdgesAppearOnMap());
+    this.nodesRelatedTo = new HashMultiMapDiff(
+        underlying.getNodesRelatedToMap());
+  }
+
+  public DynamicGraph getUnderlying() {
+    return underlying;
+  }
+
+  protected DynamicGraph underlying;
+  protected SetDiff nodeSet;
+  protected MultiMapDiff parents;
+  protected MultiMapDiff children;
+  protected MultiMapDiff edgesAppearOn;
+  protected MultiMapDiff nodesRelatedTo;
+}

src/main/java/blog/model/FuncAppTerm.java

@@ -49,6 +49,7 @@
 import blog.bn.DerivedVar;
 import blog.bn.RandFuncAppVar;
 import blog.sample.EvalContext;
+import blog.sample.TraceLabelEvalContext;
 
 /**
  * Represents a function invocation.
@@ -165,6 +166,7 @@ public Object evaluate(EvalContext context) {
     // if (argValues == null) { // Not reusing anymore since this array was
     // being used for being argument arrays for RandFuncAppVars and had to be
     // cloned anyway.
+
     Object[] oldArgValues = argValues;
     argValues = new Object[args.length];
     // }
@@ -182,8 +184,17 @@ public Object evaluate(EvalContext context) {
       }
     }
 
+    if (context instanceof TraceLabelEvalContext) {
+      ((TraceLabelEvalContext) context).addRelatedClause(this);
+    }
+    if (context instanceof TraceLabelEvalContext) {
+      ((TraceLabelEvalContext) context).setCurrentClause(this);
+    }
     Object result = f.getValueInContext(argValues, context, false);
     argValues = oldArgValues;
+    if (context instanceof TraceLabelEvalContext) {
+      ((TraceLabelEvalContext) context).removeRelatedClause(this);
+    }
     return result;
   }