Merge branch 'upstream' into Query-dependent-skolemisation

Conflicts:
	src/uk/ac/ox/cs/pagoda/approx/RLPlusOntology.java
	src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java
	src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java
	src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
	src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
	src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
	src/uk/ac/ox/cs/pagoda/reasoner/light/BasicQueryEngine.java
	src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java
	src/uk/ac/ox/cs/pagoda/util/Utility.java
	test/uk/ac/ox/cs/pagoda/junit/ClauseTester.java
	test/uk/ac/ox/cs/pagoda/junit/TestGapMappedToLower.java

3 files changed, 189 insertions, 183 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
index 02db18d..84929ad 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
@@ -1,106 +1,104 @@
 package uk.ac.ox.cs.pagoda.query;
 
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import uk.ac.ox.cs.JRDFox.store.DataStore;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
 import uk.ac.ox.cs.pagoda.MyPrefixes;
+//import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
 import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Timer;
 import uk.ac.ox.cs.pagoda.util.Utility;
-
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.Map;
-
-//import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.store.DataStore;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
 
 //public class GapByStore4ID extends GapTupleIterator<AnswerTupleID> {
 public class GapByStore4ID extends GapTupleIterator<int[]> {
 
-        protected MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes;
+        protected MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes; 
         protected TupleIterator iterator = null; 
         
 //      AnswerTupleID tuple;
-protected int[] tuple;
-        protected BasicQueryEngine m_engine;
+        protected int[] tuple; 
+        protected BasicQueryEngine m_engine; 
         protected DataStore m_store;
-        protected RDFoxTripleManager tripleManager;
-        protected long multi;
-        Map<Integer, Integer> original2gap = new HashMap<Integer, Integer>();
-        LinkedList<String> predicatesWithGap = new LinkedList<String>();
+        protected RDFoxTripleManager tripleManager; 
         
         public GapByStore4ID(BasicQueryEngine engine) {
-                m_engine = engine;
-                m_store = engine.getDataStore();
-                tripleManager = new RDFoxTripleManager(m_store, false);
+                m_engine = engine; 
+                m_store = engine.getDataStore(); 
+                tripleManager = new RDFoxTripleManager(m_store, false); 
         }
         
+        protected long multi; 
+        
         @Override
         public void compile(String program) throws JRDFStoreException {
-                clear();
+                clear(); 
 
-                boolean incrementally = true;
+                boolean incrementally = true; 
                 Timer t = new Timer();
                 long oldTripleCount = m_store.getTriplesCount();
-
+                
                 if (program != null) {
 //                      m_store.addRules(new String[] {program});
                         m_store.importRules(program);
-                        incrementally = false;
+                        incrementally = false; 
                 }
-
+                
                 m_store.applyReasoning(incrementally);
-
+                
                 long tripleCount = m_store.getTriplesCount();
-
-                Utility.logDebug("current store after materialising upper related rules: " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)",
+                        
+                Utility.logDebug("current store after materialising upper related rules: " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)", 
                                 "current store finished the materialisation of upper related rules in " + t.duration() + " seconds.");
-
+                
                 m_engine.setExpandEquality(false);
                 iterator = m_engine.internal_evaluateAgainstIDBs("select ?x ?y ?z where { ?x ?y ?z . }");
                 m_engine.setExpandEquality(true);
-
+                
                 multi = iterator.open();
-                Utility.logDebug("gap query evaluted ...");
+                Utility.logDebug("gap query evaluted ..."); 
         }
         
         @Override
         public boolean hasNext() {
-                if(iterator == null) return false;
+                if (iterator == null) return false; 
                 try {
 //                      tuple = new AnswerTupleID(3);
-                        tuple = new int[3];
-                        Integer predicate;
+                        tuple = new int[3]; 
+                        Integer predicate; 
                         for (; multi != 0; multi = iterator.getNext()) {
                                 for (int i = 0; i < 3; ++i)
 //                                      tuple.setTerm(i, (int) iterator.getResourceID(i));
-                                        tuple[i] = iterator.getResourceID(i);
-
+                                        tuple[i] = (int) iterator.getResourceID(i); 
+                                
                                 if (isRDF_TYPE()) {
 //                                      predicate = getGapPredicateID(tuple.getTerm(2));
-                                        predicate = getGapPredicateID(tuple[2]);
-                                        if(predicate == null) continue;
+                                        predicate = getGapPredicateID(tuple[2]); 
+                                        if (predicate == null) continue; 
 //                                      tuple.setTerm(2, predicate);
-                                        tuple[2] = predicate;
+                                        tuple[2] = predicate; 
                                 }
                                 else {
 //                                      predicate = getGapPredicateID(tuple.getTerm(1));
-                                        predicate = getGapPredicateID(tuple[1]);
-                                        if(predicate == null) continue;
+                                        predicate = getGapPredicateID(tuple[1]); 
+                                        if (predicate == null) continue;  
 //                                      tuple.setTerm(1, predicate);
-                                        tuple[1] = predicate;
+                                        tuple[1] = predicate; 
                                 }
-                                return true;
+                                return true; 
                         }
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
-                        return false;
+                        return false; 
                 }
-                return false;
+                return false; 
         }
-
+        
         @Override
 //      public AnswerTupleID next() {
         public int[] next() {
@@ -108,15 +106,18 @@ protected int[] tuple;
                         multi = iterator.getNext();
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
-                }
-
-                return tuple;
+                } 
+                
+                return tuple; 
         }
         
+        Map<Integer, Integer> original2gap = new HashMap<Integer, Integer>();
+        LinkedList<String> predicatesWithGap = new LinkedList<String>();
+        
         public LinkedList<String> getPredicatesWithGap() {
                 return predicatesWithGap; 
         }
-
+        
         protected Integer getGapPredicateID(int originalID) {
                 Integer gapID; 
                 if ((gapID = original2gap.get(originalID)) != null) 
@@ -137,9 +138,9 @@ protected int[] tuple;
         }
 
         protected boolean isAuxPredicate(String originalPredicate) {
-                if(originalPredicate.equals(Namespace.EQUALITY_QUOTED)) return false;
-                return originalPredicate.contains("_AUX") ||
-                                originalPredicate.startsWith("<" + Namespace.OWL_NS) ||
+                if (originalPredicate.equals(Namespace.EQUALITY_QUOTED)) return false;
+                return originalPredicate.contains("_AUX") || 
+                                originalPredicate.startsWith("<" + Namespace.OWL_NS) || 
                                 originalPredicate.startsWith("<" + Namespace.PAGODA_ORIGINAL);
         }
 
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
index 19efc58..f8e1709 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
@@ -1,141 +1,146 @@
 package uk.ac.ox.cs.pagoda.query;
 
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Set;
+
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
 import uk.ac.ox.cs.pagoda.util.UFS;
-
-import java.util.*;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
 
 public class GapByStore4ID2 extends GapByStore4ID {
+        
+        private BasicQueryEngine m_baseEngine; 
+        private UFS<String> m_equality = null, m_baseEquality = null; 
+        
+        public GapByStore4ID2(BasicQueryEngine engine, BasicQueryEngine baseEngine) {
+                super(engine);
+                m_baseEngine = baseEngine;
+        }
+        
+        @Override
+        public boolean hasNext() {
+                if (getNewGapTuple(iterator, -1)) return true; 
+                if (iterator != null) {
+                        iterator.dispose();
+                        iterator = null; 
+                }
+                return getNextGapFactAboutEquality(); 
+        }
+        
+        private boolean getNewGapTuple(TupleIterator it, int firstElement) {
+                if (it == null) return false;
+                int firstIndex = 0; 
+                tuple = new int[3]; 
+                if (firstElement > 0) {
+                        tuple[0] = firstElement;
+                        firstIndex = 1; 
+                }               
+                Integer predicate; 
+                try {
+                        for (; multi != 0; multi = it.getNext()) {
+                                for (int i = firstIndex; i < 3; ++i)
+                                        tuple[i] = (int) it.getResourceID(i - firstIndex); 
+                                
+                                if (isRDF_TYPE()) {
+                                        predicate = getGapPredicateID(tuple[2]); 
+                                        if (predicate == null) continue; 
+                                        tuple[2] = predicate; 
+                                }
+                                else {
+                                        predicate = getGapPredicateID(tuple[1]); 
+                                        if (predicate == null) continue;  
+                                        tuple[1] = predicate; 
+                                }
+                                return true; 
+                        }
+                } catch (JRDFStoreException e) {
+                        e.printStackTrace();
+                        return false; 
+                }
+                return false; 
+        }
 
-    private BasicQueryEngine m_baseEngine;
-    private UFS<String> m_equality = null, m_baseEquality = null;
-    private LinkedList<String> toAddedIndividuals = null;
-    private TupleIterator iter_individual = null;
-    private int currentID = -1;
-
-    public GapByStore4ID2(BasicQueryEngine engine, BasicQueryEngine baseEngine) {
-        super(engine);
-        m_baseEngine = baseEngine;
-    }
-
-    @Override
-    public boolean hasNext() {
-        if(getNewGapTuple(iterator, -1)) return true;
-        if(iterator != null) {
-            iterator.dispose();
-            iterator = null;
-        }
-        return getNextGapFactAboutEquality();
-    }
-
-    private boolean getNewGapTuple(TupleIterator it, int firstElement) {
-        if(it == null) return false;
-        int firstIndex = 0;
-        tuple = new int[3];
-        if(firstElement > 0) {
-            tuple[0] = firstElement;
-            firstIndex = 1;
-        }
-        Integer predicate;
-        try {
-            for(; multi != 0; multi = it.getNext()) {
-                for(int i = firstIndex; i < 3; ++i)
-                    tuple[i] = it.getResourceID(i - firstIndex);
-
-                if(isRDF_TYPE()) {
-                    predicate = getGapPredicateID(tuple[2]);
-                    if(predicate == null) continue;
-                    tuple[2] = predicate;
-                } else {
-                    predicate = getGapPredicateID(tuple[1]);
-                    if(predicate == null) continue;
-                    tuple[1] = predicate;
-                }
-                return true;
-            }
-        } catch(JRDFStoreException e) {
-            e.printStackTrace();
-            return false;
-        }
-        return false;
-    }
-
-    private boolean getNextGapFactAboutEquality() {
-        if(toAddedIndividuals == null) {
-            m_equality = m_engine.getEqualityGroups(false);
-            m_baseEquality = m_baseEngine.getEqualityGroups(false);
-            toAddedIndividuals = new LinkedList<String>();
-            Map<String, Integer> rep2cnt = new HashMap<String, Integer>();
-            Map<String, Integer> rep2cnt_base = new HashMap<String, Integer>();
-            count(m_engine, m_equality, rep2cnt);
-            count(m_baseEngine, m_baseEquality, rep2cnt_base);
-            Set<String> visitedrep = new HashSet<String>();
-            for(String individual : m_equality.keySet()) {
-                String rep = m_equality.find(individual);
-                if(visitedrep.contains(rep)) continue;
-                visitedrep.add(rep);
-                String rep_base = m_baseEquality.find(individual);
-                if(!rep2cnt.get(rep).equals(rep2cnt_base.get(rep_base))) {
-                    toAddedIndividuals.add(rep);
-                }
-            }
-
-        }
-        while(true) {
-            if(getNewGapTuple(iter_individual, currentID)) return true;
-            if(iter_individual != null) {
-                iter_individual.dispose();
-                iter_individual = null;
-            }
-            if(toAddedIndividuals.isEmpty()) {
-                currentID = -1;
-                return false;
-            }
-            String individual = toAddedIndividuals.remove();
-            currentID = tripleManager.getResourceID(individual);
-            try {
-                iter_individual =
-                        m_engine.internal_evaluateNotExpanded(String.format("select distinct ?y ?z where { <%s> ?y ?z }", individual));
-                multi = iter_individual.open();
-            } catch(JRDFStoreException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    private void count(BasicQueryEngine engine, UFS<String> equality, Map<String, Integer> map) {
-        for(String ind : equality.keySet()) {
-            Integer exist = map.get(ind);
-            if(exist == null)
-                map.put(equality.find(ind), 1);
-            else
-                map.put(equality.find(ind), ++exist);
-        }
-    }
+        private LinkedList<String> toAddedIndividuals = null; 
+        private TupleIterator iter_individual = null; 
+        private int currentID = -1; 
+        
+        private boolean getNextGapFactAboutEquality() {
+                if (toAddedIndividuals == null) {
+                        m_equality = m_engine.getEqualityGroups(false); 
+                        m_baseEquality = m_baseEngine.getEqualityGroups(false);
+                        toAddedIndividuals = new LinkedList<String>(); 
+                        Map<String, Integer> rep2cnt = new HashMap<String, Integer>();  
+                        Map<String, Integer> rep2cnt_base = new HashMap<String, Integer>();  
+                        count(m_engine, m_equality, rep2cnt); 
+                        count(m_baseEngine, m_baseEquality, rep2cnt_base);
+                        Set<String> visitedrep = new HashSet<String>();
+                        for (String individual : m_equality.keySet()) {
+                                String rep = m_equality.find(individual);
+                                if (visitedrep.contains(rep)) continue; 
+                                visitedrep.add(rep);
+                                String rep_base = m_baseEquality.find(individual);
+                                if (!rep2cnt.get(rep).equals(rep2cnt_base.get(rep_base))) {
+                                        toAddedIndividuals.add(rep); 
+                                }
+                        }
 
-    @Override
-    public int[] next() {
-        try {
-            if(iterator != null)
-                multi = iterator.getNext();
-            else if(iter_individual != null)
-                multi = iter_individual.getNext();
-            else
-                multi = 0;
-        } catch(JRDFStoreException e) {
-            e.printStackTrace();
-        }
-        return tuple;
-    }
+                }
+                while (true) {
+                        if (getNewGapTuple(iter_individual, currentID)) return true;
+                        if (iter_individual != null) {
+                                iter_individual.dispose();
+                                iter_individual = null; 
+                        }
+                        if (toAddedIndividuals.isEmpty()) {
+                                currentID = -1; 
+                                return false;
+                        }
+                        String individual = toAddedIndividuals.remove();
+                        currentID = tripleManager.getResourceID(individual); 
+                        try {
+                                iter_individual = m_engine.internal_evaluateNotExpanded(String.format("select distinct ?y ?z where { <%s> ?y ?z }", individual));
+                                multi = iter_individual.open(); 
+                        } catch (JRDFStoreException e) {
+                                e.printStackTrace();
+                        }
+                }
+        }
 
-    public void clear() {
-        super.clear();
-        if(iter_individual != null) {
-            iter_individual.dispose();
-            iter_individual = null;
-        }
-    }
+        private void count(BasicQueryEngine engine, UFS<String> equality, Map<String, Integer> map) {
+                for (String ind : equality.keySet()) {
+                        Integer exist = map.get(ind);
+                        if (exist == null)
+                                map.put(equality.find(ind), 1); 
+                        else 
+                                map.put(equality.find(ind), ++exist); 
+                }
+        }
 
+        @Override
+        public int[] next() {
+                try {
+                        if (iterator != null)
+                                multi = iterator.getNext();
+                        else if (iter_individual != null)
+                                multi = iter_individual.getNext();
+                        else 
+                                multi = 0; 
+                } catch (JRDFStoreException e) {
+                        e.printStackTrace();
+                } 
+                return tuple; 
+        }
+        
+        public void clear() {
+                super.clear();
+                if (iter_individual != null) {
+                        iter_individual.dispose();
+                        iter_individual = null; 
+                }
+        }
+        
 }
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java b/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
index 2983b2e..bf11168 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
@@ -24,5 +24,5 @@ public abstract class GapTupleIterator<T> implements Iterator<T> {
         public abstract void addTo(DataStore store) throws JRDFStoreException;
         
         public abstract void clear();
-
+        
 }