cleanup

Author: Lukas Molzberger

src/main/java/network/aika/Document.java

@@ -20,6 +20,7 @@
 import network.aika.lattice.Converter;
 import network.aika.lattice.Node;
 import network.aika.lattice.NodeActivation;
+import network.aika.lattice.NodeQueue;
 import network.aika.neuron.INeuron;
 import network.aika.neuron.Synapse;
 import network.aika.neuron.activation.Activation;
@@ -73,7 +74,7 @@ public class Document implements Comparable<Document> {
     private Model model;
     private int threadId;
 
-    private NodeQueue nodeQueue = new NodeQueue();
+    private NodeQueue nodeQueue = new NodeQueue(this);
     private ValueQueue valueQueue = new ValueQueue();
     private UpperBoundQueue ubQueue = new UpperBoundQueue();
     private Linker linker;
@@ -234,7 +235,17 @@ public String toString() {
 	}
 
 
-	public Position lookupFinalPosition(int pos) {
+    public UpperBoundQueue getUpperBoundQueue() {
+        return ubQueue;
+    }
+
+
+    public NodeQueue getNodeQueue() {
+        return nodeQueue;
+    }
+
+
+    public Position lookupFinalPosition(int pos) {
         Position p = positions.get(pos);
 
         if(p == null) {
@@ -333,7 +344,7 @@ public int compareTo(Document doc) {
     public void propagate() {
         boolean flag = true;
         while(flag) {
-            nodeQueue.processChanges();
+            nodeQueue.process();
             flag = ubQueue.process();
         }
     }
@@ -471,22 +482,6 @@ public void commit() {
     }
 
 
-
-
-    public void addToUpperBoundQueue(Link l) {
-        ubQueue.add(l);
-    }
-
-    public void addToUpperBoundQueue(Activation act) {
-        ubQueue.add(act);
-    }
-
-
-    public void addToNodeQueue(Node n) {
-        nodeQueue.add(n);
-    }
-
-
     /**
      * Removes the activations of this document from the model again.
      */
@@ -589,60 +584,6 @@ public String activationsToString() {
     }
 
 
-    private class NodeQueue {
-
-        private final TreeSet<Node> queue = new TreeSet<>(
-                (n1, n2) -> Node.compareRank(threadId, n1, n2)
-        );
-
-        private long queueIdCounter = 0;
-
-        private void add(Node n) {
-            if(!n.isQueued(threadId, queueIdCounter++)) {
-                queue.add(n);
-            }
-        }
-
-        private void processChanges() {
-            while(!queue.isEmpty()) {
-                Node n = queue.pollFirst();
-
-                n.setNotQueued(threadId);
-                n.processChanges(Document.this);
-            }
-        }
-    }
-
-
-    private class UpperBoundQueue {
-        private final ArrayDeque<Activation> queue = new ArrayDeque<>();
-
-        private void add(Link l) {
-            if(!l.isRecurrent()) {
-                add(l.getOutput());
-            }
-        }
-
-        private void add(Activation act) {
-            if(!act.ubQueued && act.inputValue == null) {
-                act.ubQueued = true;
-                queue.addLast(act);
-            }
-        }
-
-        private boolean process() {
-            boolean flag = false;
-            while(!queue.isEmpty()) {
-                flag = true;
-                Activation act = queue.pollFirst();
-                act.ubQueued = false;
-
-                act.processBounds();
-            }
-            return flag;
-        }
-    }
-
     public void dumpOscillatingActivations() {
         activatedNeurons.stream()
                 .flatMap(n -> n.getActivations(this, false))

src/main/java/network/aika/lattice/AndNode.java

@@ -70,8 +70,24 @@ private void init() {
     }
 
 
-    public void propagate(AndActivation act) {
-        apply(act);
+    @Override
+    protected void propagate(AndActivation act) {
+        if (andChildren != null) {
+            for (Link fl : act.inputs) {
+                if(fl == null) continue;
+
+                NodeActivation<?> pAct = fl.input;
+
+                for (Link sl : pAct.outputsToAndNode.values()) {
+                    NodeActivation secondAct = sl.output;
+                    if (act != secondAct) {
+                        applyIntern(act, fl.refAct, fl.ref, fl.rv, secondAct, sl.refAct, sl.ref, sl.rv);
+                    }
+                }
+            }
+        }
+
+        propagateToOrNode(act);
     }
 
 
@@ -95,26 +111,6 @@ void processActivation(AndActivation act) {
     }
 
 
-    @Override
-    void apply(AndActivation act) {
-        if (andChildren != null) {
-            for (Link fl : act.inputs) {
-                if(fl == null) continue;
-
-                NodeActivation<?> pAct = fl.input;
-
-                for (Link sl : pAct.outputsToAndNode.values()) {
-                    NodeActivation secondAct = sl.output;
-                    if (act != secondAct) {
-                        applyIntern(act, fl.refAct, fl.ref, fl.rv, secondAct, sl.refAct, sl.ref, sl.rv);
-                    }
-                }
-            }
-        }
-
-        OrNode.processCandidate(this, act, false);
-    }
-
 
     private void applyIntern(AndActivation act, InputActivation refAct, Refinement ref, RefValue rv, NodeActivation secondAct, InputActivation secondRefAct, Refinement secondRef, RefValue secondRv) {
         Document doc = act.getDocument();
@@ -159,7 +155,7 @@ private AndActivation lookupAndActivation(NodeActivation<?> input, Refinement re
     }
 
 
-    public RefValue extend(int threadId, Document doc, Refinement firstRef) {
+    RefValue expand(int threadId, Document doc, Refinement firstRef) {
         if(!firstRef.isConvertible()) return null;
 
         RefValue firstRV = getAndChild(firstRef);
@@ -178,45 +174,17 @@ public RefValue extend(int threadId, Document doc, Refinement firstRef) {
         for(Entry firstParent: parents) {
             Node parentNode = firstParent.rv.parent.get(doc);
 
-            Relation[] secondParentRelations = new Relation[firstRef.relations.length() - 1];
-            for(int i = 0; i < firstRef.relations.length(); i++) {
-                Integer j = firstParent.rv.reverseOffsets[i];
-                if(j != null) {
-                    secondParentRelations[j] = firstRef.relations.get(i);
-                }
-            }
-
-            Refinement secondParentRef = new Refinement(new RelationsMap(secondParentRelations), firstRef.input);
-
-            RefValue secondParentRV = parentNode.extend(threadId, doc, secondParentRef);
+            Refinement secondParentRef = new Refinement(getParentRelations(firstRef, firstParent), firstRef.input);
+            RefValue secondParentRV = parentNode.expand(threadId, doc, secondParentRef);
 
             if(secondParentRV == null) {
                 continue;
             }
 
-            Relation[] secondRelations = new Relation[firstParent.ref.relations.length() + 1];
-            for(int i = 0; i < firstParent.ref.relations.length(); i++) {
-                int j = secondParentRV.offsets[i];
-                secondRelations[j] = firstParent.ref.relations.get(i);
-            }
-
-            Relation rel = firstRef.relations.get(firstParent.rv.refOffset);
-            if(rel != null) {
-                secondRelations[secondParentRV.refOffset] = rel.invert();
-            }
-
-            Refinement secondRef = new Refinement(new RelationsMap(secondRelations), firstParent.ref.input);
-
-            Integer[] secondOffsets = new Integer[secondParentRV.offsets.length + 1];
-            for(int i = 0; i < firstParent.rv.reverseOffsets.length; i++) {
-                Integer j = firstParent.rv.reverseOffsets[i];
-                if(j != null) {
-                    secondOffsets[secondParentRV.offsets[j]] = i;
-                }
-            }
-            secondOffsets[secondParentRV.refOffset] = firstRefOffset;
+            Refinement secondRef = new Refinement(getRelations(firstRef, firstParent, secondParentRV), firstParent.ref.input);
+            RefValue secondRV = new RefValue(getOffsets(firstRefOffset, firstParent, secondParentRV), firstOffsets[firstParent.rv.refOffset], secondParentRV.child);
 
-            nextLevelParents.add(new Entry(secondRef, new RefValue(secondOffsets, firstOffsets[firstParent.rv.refOffset], secondParentRV.child)));
+            nextLevelParents.add(new Entry(secondRef, secondRV));
         }
 
         firstRV = new RefValue(firstOffsets, firstRefOffset, provider);
@@ -226,6 +194,45 @@ public RefValue extend(int threadId, Document doc, Refinement firstRef) {
     }
 
 
+    private RelationsMap getParentRelations(Refinement firstRef, Entry firstParent) {
+        Relation[] secondParentRelations = new Relation[firstRef.relations.length() - 1];
+        for(int i = 0; i < firstRef.relations.length(); i++) {
+            Integer j = firstParent.rv.reverseOffsets[i];
+            if(j != null) {
+                secondParentRelations[j] = firstRef.relations.get(i);
+            }
+        }
+        return new RelationsMap(secondParentRelations);
+    }
+
+
+    private static RelationsMap getRelations(Refinement firstRef, Entry firstParent, RefValue secondParentRV) {
+        Relation[] secondRelations = new Relation[firstParent.ref.relations.length() + 1];
+        for(int i = 0; i < firstParent.ref.relations.length(); i++) {
+            int j = secondParentRV.offsets[i];
+            secondRelations[j] = firstParent.ref.relations.get(i);
+        }
+
+        Relation rel = firstRef.relations.get(firstParent.rv.refOffset);
+        if(rel != null) {
+            secondRelations[secondParentRV.refOffset] = rel.invert();
+        }
+        return new RelationsMap(secondRelations);
+    }
+
+
+    private static Integer[] getOffsets(int firstRefOffset, Entry firstParent, RefValue secondParentRV) {
+        Integer[] secondOffsets = new Integer[secondParentRV.offsets.length + 1];
+        for(int i = 0; i < firstParent.rv.reverseOffsets.length; i++) {
+            Integer j = firstParent.rv.reverseOffsets[i];
+            if(j != null) {
+                secondOffsets[secondParentRV.offsets[j]] = i;
+            }
+        }
+        secondOffsets[secondParentRV.refOffset] = firstRefOffset;
+        return secondOffsets;
+    }
+
 
     static boolean createAndNode(Model m, Document doc, List<Entry> parents, int level) {
         if (parents != null) {

src/main/java/network/aika/lattice/Converter.java

@@ -217,7 +217,7 @@ private NodeContext expandNode(NodeContext nc, Synapse s) {
             NodeContext nln = new NodeContext();
             nln.offsets = new Synapse[nc.offsets.length + 1];
             AndNode.Refinement ref = new AndNode.Refinement(new AndNode.RelationsMap(relations), s.getInput().get().getOutputNode());
-            AndNode.RefValue rv = nc.node.extend(threadId, doc, ref);
+            AndNode.RefValue rv = nc.node.expand(threadId, doc, ref);
             if(rv == null) {
                 return null;
             }

src/main/java/network/aika/lattice/InputNode.java

@@ -20,7 +20,6 @@
 import network.aika.Document;
 import network.aika.Model;
 import network.aika.Provider;
-import network.aika.neuron.INeuron;
 import network.aika.neuron.Neuron;
 import network.aika.neuron.activation.Position;
 import network.aika.neuron.relation.Relation;
@@ -77,11 +76,6 @@ public void addActivation(Activation inputAct) {
     }
 
 
-    public void propagate(InputActivation act) {
-        apply(act);
-    }
-
-
     public void reprocessInputs(Document doc) {
         inputNeuron.get(doc).getActivations(doc, false).forEach(act -> {
 //            act.repropagateV = markedCreated;
@@ -121,8 +115,7 @@ void removeAndChild(AndNode.Refinement ref) {
     }
 
 
-
-    public RefValue extend(int threadId, Document doc, Refinement ref) {
+    public RefValue expand(int threadId, Document doc, Refinement ref) {
         if(!ref.isConvertible()) return null;
 
         Relation rel = ref.relations.get(0);
@@ -151,14 +144,14 @@ public RefValue extend(int threadId, Document doc, Refinement ref) {
      * @param act
      */
     @Override
-    void apply(InputActivation act) {
+    protected void propagate(InputActivation act) {
         try {
             lock.acquireReadLock();
             if (andChildren != null) {
                 TreeMap<AndNode.Refinement, AndNode.RefValue> children;
                 if(andChildren.size() > CHILD_NODE_THRESHOLD) {
                     children = nonExactAndChildren;
-                    applyExactRelations(act);
+                    propagateWithExactRelations(act);
                 } else {
                     children = andChildren;
                 }
@@ -167,7 +160,7 @@ void apply(InputActivation act) {
                     children.forEach((ref, rv) -> {
                         InputNode in = ref.input.getIfNotSuspended();
                         if (in != null) {
-                            addNextLevelActivations(in, ref, rv.child.get(act.getDocument()), act);
+                            in.addNextLevelActivations(ref, rv.child.get(act.getDocument()), act);
                         }
                     });
                 }
@@ -176,11 +169,11 @@ void apply(InputActivation act) {
             lock.releaseReadLock();
         }
 
-        OrNode.processCandidate(this, act, false);
+        propagateToOrNode(act);
     }
 
 
-    private void applyExactRelations(InputActivation act) {
+    private void propagateWithExactRelations(InputActivation act) {
         Activation iAct = act.input;
         Document doc = act.getDocument();
 
@@ -190,23 +183,23 @@ private void applyExactRelations(InputActivation act) {
                 for (Map.Entry<AndNode.Refinement, AndNode.RefValue> mea : andChildren.subMap(
                         new Refinement(RelationsMap.MIN, in),
                         new Refinement(RelationsMap.MAX, in)).entrySet()) {
-                    addNextLevelActivations(in.get(doc), mea.getKey(), mea.getValue().child.get(doc), act);
+                    in.get(doc).addNextLevelActivations(mea.getKey(), mea.getValue().child.get(doc), act);
                 }
             }
         }
     }
 
 
-    private static void addNextLevelActivations(InputNode secondNode, Refinement ref, AndNode nln, InputActivation act) {
+    private void addNextLevelActivations(Refinement ref, AndNode nln, InputActivation act) {
         Document doc = act.getDocument();
 
-        if(secondNode.inputNeuron.get().isEmpty(doc)) return;
+        if(inputNeuron.get().isEmpty(doc)) return;
 
         Activation iAct = act.input;
 
         if(act.repropagateV != null && act.repropagateV != nln.markedCreated) return;
 
-        ref.relations.get(0).getActivations(secondNode.inputNeuron.get(doc), iAct)
+        ref.relations.get(0).getActivations(inputNeuron.get(doc), iAct)
                 .filter(secondIAct -> secondIAct.getOutputNodeActivation() != null)
                 .map(secondIAct -> secondIAct.getOutputNodeActivation())
                 .filter(secondAct -> secondAct != null && secondAct.registered)