public static Graph getGraph() { Graph g = Factory.createGraphMem(); g.add( new Triple( NodeFactory.createURI("http://example.com/subject"), NodeFactory.createURI("http://example.com/predicate"), NodeFactory.createURI("http://example.com/object"))); g.add( new Triple( NodeFactory.createBlankNode(BlankNodeId.create("a")), NodeFactory.createURI("http://example.com/p1"), NodeFactory.createBlankNode(BlankNodeId.create("b")))); g.add( new Triple( NodeFactory.createBlankNode(BlankNodeId.create("b")), NodeFactory.createURI("http://example.com/p2"), NodeFactory.createLiteral("foo"))); g.add( new Triple( NodeFactory.createURI("http://example.com/ns/e"), NodeFactory.createURI("http://example.com/ns/p5"), NodeFactory.createLiteral("verify base works"))); return g; }
@Test public void testGraph() throws Exception { Graph graph = new PeopleGraphImpl().graphFor(1); graph.add(new PersonImpl(1, "Zequinha", 10.0)); graph.add(new PersonImpl(2, "Barbosa", 20.0)); List<Person> closest = graph.getClosestFriends(5); assertEquals(2, closest.size()); }
@Test public void graphWithTwoNodesAndTwoNeighbours() throws Exception { Node node = new Node("1"); node.addNeighbour(new Node("3")); Node node2 = new Node("2"); node2.addNeighbour(new Node("4")); graph.add(node); graph.add(node2); assertEquals("1 3\n2 4\n", serializeGraph()); }
/** Check that the standard reifier will note, but not hide, reification quads. */ public void testStandard() { Graph g = getGraph(); assertFalse(ReifierStd.hasTriple(g, triple("s p o"))); g.add(NodeCreateUtils.createTriple("x rdf:subject s")); assertEquals(1, g.size()); g.add(NodeCreateUtils.createTriple("x rdf:predicate p")); assertEquals(2, g.size()); g.add(NodeCreateUtils.createTriple("x rdf:object o")); assertEquals(3, g.size()); g.add(NodeCreateUtils.createTriple("x rdf:type rdf:Statement")); assertEquals(4, g.size()); assertTrue(ReifierStd.hasTriple(g, triple("s p o"))); }
private void getNewNodes() { Vector levelNodes = new Vector(); Vector nextLevelNodes = new Vector(); Vector passedNodes = new Vector(); levelNodes.add(centerNode.name); for (int level = 0; level <= Config.navigationDepth; level++) { for (Enumeration e = levelNodes.elements(); e.hasMoreElements(); ) { String nodeName = (String) e.nextElement(); if (!passedNodes.contains(nodeName)) { passedNodes.add(nodeName); Node node = graph.nodeFromName(nodeName); if (node == null) { node = xmlReader.getNode(nodeName); graph.add(node); } node.passed = true; Set linkSet = node.links.keySet(); for (Iterator it = linkSet.iterator(); it.hasNext(); ) { String neighbourName = (String) it.next(); if (!passedNodes.contains(neighbourName) && !levelNodes.contains(neighbourName)) { nextLevelNodes.add(neighbourName); } } } } levelNodes = nextLevelNodes; nextLevelNodes = new Vector(); } }
public static void main(String[] args) throws FileNotFoundException { Scanner file = new Scanner(new File("connected.txt")); for (int i = 0; i < 3; i++) { file.next(); } int totalVector = Integer.parseInt(file.next()); Graph graph = new Graph(totalVector); System.out.println(totalVector); while (file.hasNext()) { String s = file.next(); char s1 = s.charAt(1); char s2 = s.charAt(3); Vertex v1 = new Vertex(s1); Vertex v2 = new Vertex(s2); String c = file.next(); char cArray[] = c.toCharArray(); char ccArray[] = new char[cArray.length - 2]; for (int i = 1; i < cArray.length - 1; i++) { ccArray[i - 1] = cArray[i]; } int cost = Integer.parseInt(String.valueOf(ccArray)); graph.add(v1, v2, cost); } file.close(); graph.printData(); graph.DFTraversal(graph, graph.headvertex); graph.miniumSpanningTree(graph); }
@Test public void graphWithOneNodeAndOneNeighbourReturnsNodeAndNeighbour() throws Exception { Node node = new Node("1"); node.addNeighbour(new Node("2")); graph.add(node); assertEquals("1 2\n", serializeGraph()); }
public void testQuadRemove() { Graph g = getGraph(); assertEquals(0, g.size()); Triple s = NodeCreateUtils.createTriple("x rdf:subject s"); Triple p = NodeCreateUtils.createTriple("x rdf:predicate p"); Triple o = NodeCreateUtils.createTriple("x rdf:object o"); Triple t = NodeCreateUtils.createTriple("x rdf:type rdf:Statement"); g.add(s); g.add(p); g.add(o); g.add(t); assertEquals(4, g.size()); g.delete(s); g.delete(p); g.delete(o); g.delete(t); assertEquals(0, g.size()); }
public void extractInto(Node root) { active.add(root); Iterator<Triple> it = extractFrom.find(root, Node.ANY, Node.ANY); while (it.hasNext()) { Triple t = it.next(); Node subRoot = t.getObject(); toUpdate.add(t); if (!(active.contains(subRoot) || b.stopAt(t))) extractInto(subRoot); } }
public void testKevinCaseB() { Graph G = getGraph(); Node X = node("x"), Y = node("y"); Node a = node("a"), b = node("b"), c = node("c"); G.add(Triple.create(X, RDF.Nodes.subject, Y)); try { ReifierStd.reifyAs(G, X, Triple.create(a, b, c)); fail("X already has subject Y: cannot make it a"); } catch (CannotReifyException e) { pass(); } }
/** * Adds the given triple to the graph. * * @param subject The subject node * @param predicate The predicate node * @param object The object node * @param graph The graph we are adding the triple to * @throws MetaDataException */ public static void addTriple(Node subject, Node predicate, Node object, Graph graph) throws MetaDataException { try { // Add the type triple graph.add((SubjectNode) subject, (PredicateNode) predicate, (ObjectNode) object); } catch (GraphException graphException) { throw new MetaDataException( "Failed to add triple for predicate: " + predicate, graphException); } }
/** * Update the triangulation by removing the cavity triangles and then filling the cavity with * new triangles. * * @param site the site that created the cavity * @param cavity the triangles with site in their circumcircle * @return one of the new triangles */ private Triangle update(Pnt site, Set<Triangle> cavity) { Set<Set<Pnt>> boundary = new HashSet<Set<Pnt>>(); Set<Triangle> theTriangles = new HashSet<Triangle>(); // Find boundary facets and adjacent triangles for (Triangle triangle : cavity) { theTriangles.addAll(neighbors(triangle)); for (Pnt vertex : triangle) { Set<Pnt> facet = triangle.facetOpposite(vertex); if (boundary.contains(facet)) boundary.remove(facet); else boundary.add(facet); } } theTriangles.removeAll(cavity); // Adj triangles only // Remove the cavity triangles from the triangulation for (Triangle triangle : cavity) triGraph.remove(triangle); // Build each new triangle and add it to the // triangulation Set<Triangle> newTriangles = new HashSet<Triangle>(); for (Set<Pnt> vertices : boundary) { vertices.add(site); Triangle tri = new Triangle(vertices); triGraph.add(tri); newTriangles.add(tri); } // Update the graph links for each new triangle theTriangles.addAll(newTriangles); // Adj triangle + new // triangles for (Triangle triangle : newTriangles) for (Triangle other : theTriangles) if (triangle.isNeighbor(other)) triGraph.add(triangle, other); // Return one of the new triangles return newTriangles.iterator().next(); }
/** * Adds a set of precomputed triples to the deductions store. These do not, themselves, fire any * rules but provide additional axioms that might enable future rule firing when real data is * added. Used to implement bindSchema processing in the parent Reasoner. * * @return return true if the rule set has also been loaded */ protected boolean preloadDeductions(Graph preloadIn) { Graph d = fdeductions.getGraph(); BasicForwardRuleInfGraph preload = (BasicForwardRuleInfGraph) preloadIn; // If the rule set is the same we can reuse those as well if (preload.rules == rules) { // Load raw deductions for (Iterator<Triple> i = preload.find(null, null, null); i.hasNext(); ) { d.add(i.next()); } engine.setRuleStore(preload.engine.getRuleStore()); return true; } else { return false; } }
@Override protected Boolean processMethod() throws AsyncException { Graph d = fdeductions.getGraph(); BasicForwardRuleInfGraph preload = (BasicForwardRuleInfGraph) preloadIn; // If the rule set is the same we can reuse those as well if (preload.rules == rules) { // Load raw deductions for (Iterator<Triple> i = preload.find(getHandler(""), null, null, null); i.hasNext(); ) { d.add(getHandler(""), i.next()); } engine.setRuleStore(preload.engine.getRuleStore()); return true; } else { return false; } }
public void addAll(Collection<? extends Vertex> V) { for (Vertex v : V) add(v); }
@Override public void add(Triple t) { base.add(t); getEventManager().notifyAddTriple(this, t); }
@Override public void performAdd(Triple t) { base.add(t); }
private void addNode(String nodeName) { graph.add(new Node(nodeName)); }
@Override public final boolean add(GNode<N> n) { return g.add(n); }
public Vertex vert(String s, Double lat, Double longx) { Vertex v = new Vertex(s, lat, longx); add(v); return v; }
public Vertex vert(String s) { Vertex v = new Vertex(s); add(v); return v; }
@Override public final boolean add(GNode<N> n, byte flags) { return g.add(n, flags); }
@Override public void add(Edge edge) { super.add(edge); super.add(edge.getTransposedEdge()); }
/** * All sites must fall within the initial triangle. * * @param triangle the initial triangle */ public Triangulation(Triangle triangle) { triGraph = new Graph<Triangle>(); triGraph.add(triangle); mostRecent = triangle; }
public void testKevinCaseA() { Graph G = getGraph(); Node X = node("x"), a = node("a"), b = node("b"), c = node("c"); G.add(Triple.create(X, RDF.Nodes.type, RDF.Nodes.Statement)); ReifierStd.reifyAs(G, X, Triple.create(a, b, c)); }
public void navigateFirst(String nodeName) { Node node = xmlReader.getNode(nodeName); graph.add(node); navigateTo(node); }
public ZDiscoveryController(IRobot robot, Graph nodeGraph) { super(robot); this.graph = nodeGraph; nodeGraph.setLast(null); nodeGraph.add(new JunctionNode(robot), 0); }