1 files changed, 112 insertions, 0 deletions

diff --git a/test/uk/ac/ox/cs/data/sample/RandomWalkMulti.java b/test/uk/ac/ox/cs/data/sample/RandomWalkMulti.java
new file mode 100644
index 0000000..592f249
--- /dev/null
+++ b/test/uk/ac/ox/cs/data/sample/RandomWalkMulti.java
@@ -0,0 +1,112 @@
+package uk.ac.ox.cs.data.sample;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.Stack;
+
+import org.openrdf.rio.RDFHandlerException;
+import org.openrdf.rio.turtle.TurtleWriter;
+
+import uk.ac.ox.cs.pagoda.util.Utility;
+
+
+public class RandomWalkMulti extends RandomWalk {
+        
+        public RandomWalkMulti(RDFGraph graph, TurtleWriter writer) {
+                super(graph, writer);
+        }
+
+        Queue<Integer> queue = new LinkedList<Integer>();
+
+        @Override
+        public void sample() throws RDFHandlerException {
+                getStartNodes();
+
+                Utility.logInfo(queue.size());
+                
+                int u, v, pick, index; 
+                int individualLimit = statementLimit / queue.size(), currentLimit = 0; 
+                RDFEdge edge; 
+                List<RDFEdge> edges;
+                Stack<Integer> stack = new Stack<Integer>();
+                while (true) {
+                        if (noOfStatements >= statementLimit) {
+                                System.out.println("The number of statements in the sampling: " + noOfStatements); 
+                                return ;
+                        }
+                        if (noOfStatements >= currentLimit) {
+                                stack.clear();
+                        }
+                        
+                        if (stack.isEmpty()) {
+                                if (queue.isEmpty())
+                                        v = rand.nextInt(m_graph.numberOfIndividuals); 
+                                else {
+                                        v = queue.poll();
+                                        currentLimit += individualLimit;
+                                }
+                                stack.add(v);
+//                              Utility.logInfo(noOfStart + " new start: " + m_graph.getRawString(v));
+                                visit(v);
+                        }
+                        u = stack.peek(); 
+                        if (rand.nextInt(100) < 15) {
+                                stack.pop(); 
+                                continue;
+                        }
+                        if ((edges = m_graph.edges.get(u)) == null || edges.size() == 0) {
+                                stack.clear();
+                                continue; 
+                        }
+                        
+                        index = 0;
+                        pick = rand.nextInt(edges.size()); 
+                        for (Iterator<RDFEdge> iter = edges.iterator(); iter.hasNext(); ++index) {
+                                edge = iter.next(); 
+                                if (index == pick) {
+                                        stack.add(v = edge.m_dst);
+                                        visit(v);
+                                        m_writer.handleStatement(m_graph.getStatement(u, edge.m_label, edge.m_dst));
+                                        ++noOfStatements; 
+                                        iter.remove(); 
+                                }
+                                        
+                        }
+                }
+        }
+
+        private void getStartNodes() throws RDFHandlerException {
+                Set<Integer> coveredConcepts = new HashSet<Integer>();
+                Integer concept;
+                
+                Iterator<Integer> iter; 
+                for (Map.Entry<Integer, LinkedList<Integer>> entry: m_graph.labels.entrySet()) {
+                        iter = entry.getValue().iterator();
+                        concept = null; 
+                        
+                        while (iter.hasNext()) {
+                                if (!(coveredConcepts.contains(concept = iter.next()))) {
+                                        break;
+                                }
+                                else concept = null; 
+
+                        }
+                        
+                        if (concept == null) continue;
+                        else {
+                                queue.add(entry.getKey());
+                                coveredConcepts.add(concept); 
+                                while (iter.hasNext()) 
+                                        coveredConcepts.add(iter.next()); 
+                        }
+                }
+
+        }
+        
+
+}