public Nodes dual() { Graph graph = belongsTo(); Nodes vertices = graph.nodes(Node.Duality.hvert); Nodes edges = graph.nodes(Node.Duality.hedge); return (this == vertices) ? edges : (this == edges) ? vertices : this; }
public Node.Duality duality() { Graph graph = belongsTo(); Nodes vertices = graph.nodes(Node.Duality.hvert); Nodes edges = graph.nodes(Node.Duality.hedge); return (this == vertices) ? Node.Duality.hvert : (this == edges) ? Node.Duality.hedge : Node.Duality.hvert; }
static GraphDescription create(Graph graph) { if (graph == null) { return EMPTY; } Map<String, NODE> nodes = new HashMap<String, NODE>(); for (NODE node : graph.nodes()) { if (nodes.put(defined(node.name()), node) != null) { throw new IllegalArgumentException("Node \"" + node.name() + "\" defined more than once"); } } Map<String, REL> rels = new HashMap<String, REL>(); List<REL> relationships = new ArrayList<REL>(); for (REL rel : graph.relationships()) { createIfAbsent(nodes, rel.start()); createIfAbsent(nodes, rel.end()); String name = rel.name(); if (!name.equals("")) { if (rels.put(name, rel) != null) { throw new IllegalArgumentException( "Relationship \"" + name + "\" defined more than once"); } } relationships.add(rel); } parse(graph.value(), nodes, relationships); return new GraphDescription( nodes.values().toArray(NO_NODES), relationships.toArray(NO_RELS), graph.autoIndexNodes(), graph.autoIndexRelationships()); }
public static String format(Graph graph) { Map<String, Object> map = new HashMap<String, Object>(); map.put("type", graph.type()); map.put("label", graph.label()); map.put("families", graph.factory().families().toArray()); if (graph.factory().contains(GraphFactory.Family.dual)) { map.put("nodes:hvert", graph.nodes(Node.Duality.hvert)); map.put("hedge:hedge", graph.nodes(Node.Duality.hedge)); } else { map.put("nodes", graph.nodes()); } if (graph.factory().contains(GraphFactory.Family.fractal)) { map.put("up", graph.up()); } return format(map); }
private Graph makeGraph( int nodeCount, double edgeDensityLower, double edgeDensityUpper, String label) { this.nodeCount = nodeCount; this.label = label; random = new Random(0); nodes = initializeNodes(); populateNeighbors(edgeDensityLower, edgeDensityUpper); Graph graph = new Graph(); graph.nodes = Sets.newHashSet(nodes); graph.label = label; return graph; }
@After public void validateGraphState() { new EqualsTester() .addEqualityGroup(network, Graphs.copyOf(network), ImmutableNetwork.copyOf(network)) .testEquals(); String networkString = network.toString(); assertThat(networkString).contains("isDirected: " + network.isDirected()); assertThat(networkString).contains("allowsParallelEdges: " + network.allowsParallelEdges()); assertThat(networkString).contains("allowsSelfLoops: " + network.allowsSelfLoops()); int nodeStart = networkString.indexOf("nodes:"); int edgeStart = networkString.indexOf("edges:"); String nodeString = networkString.substring(nodeStart, edgeStart); String edgeString = networkString.substring(edgeStart); Graph<Integer> asGraph = network.asGraph(); assertThat(network.nodes()).isEqualTo(asGraph.nodes()); assertThat(network.nodeOrder()).isEqualTo(asGraph.nodeOrder()); assertThat(network.isDirected()).isEqualTo(asGraph.isDirected()); assertThat(network.allowsSelfLoops()).isEqualTo(asGraph.allowsSelfLoops()); for (String edge : network.edges()) { // TODO(b/27817069): Consider verifying the edge's incident nodes in the string. assertThat(edgeString).contains(edge); Iterator<Integer> endpointsIterator = network.incidentNodes(edge).iterator(); Integer nodeA = endpointsIterator.next(); Integer nodeB = endpointsIterator.next(); assertThat(network.edgesConnecting(nodeA, nodeB)).contains(edge); assertThat(network.successors(nodeA)).contains(nodeB); assertThat(network.adjacentNodes(nodeA)).contains(nodeB); assertThat(network.outEdges(nodeA)).contains(edge); assertThat(network.incidentEdges(nodeA)).contains(edge); assertThat(network.predecessors(nodeB)).contains(nodeA); assertThat(network.adjacentNodes(nodeB)).contains(nodeA); assertThat(network.inEdges(nodeB)).contains(edge); assertThat(network.incidentEdges(nodeB)).contains(edge); for (Integer incidentNode : network.incidentNodes(edge)) { assertThat(network.nodes()).contains(incidentNode); for (String adjacentEdge : network.incidentEdges(incidentNode)) { assertTrue( edge.equals(adjacentEdge) || network.adjacentEdges(edge).contains(adjacentEdge)); } } } for (Integer node : network.nodes()) { assertThat(nodeString).contains(node.toString()); assertThat(network.adjacentNodes(node)).isEqualTo(asGraph.adjacentNodes(node)); assertThat(network.predecessors(node)).isEqualTo(asGraph.predecessors(node)); assertThat(network.successors(node)).isEqualTo(asGraph.successors(node)); for (Integer otherNode : network.nodes()) { Set<String> edgesConnecting = network.edgesConnecting(node, otherNode); boolean isSelfLoop = node.equals(otherNode); if (network.isDirected() || !isSelfLoop) { assertThat(edgesConnecting) .isEqualTo(Sets.intersection(network.outEdges(node), network.inEdges(otherNode))); } if (!network.allowsParallelEdges()) { assertThat(edgesConnecting.size()).isAtMost(1); } if (!network.allowsSelfLoops() && isSelfLoop) { assertThat(edgesConnecting).isEmpty(); } for (String edge : edgesConnecting) { assertThat(network.incidentNodes(edge)).isEqualTo(Endpoints.of(network, node, otherNode)); } } for (String incidentEdge : network.incidentEdges(node)) { assertTrue( network.inEdges(node).contains(incidentEdge) || network.outEdges(node).contains(incidentEdge)); assertThat(network.edges()).contains(incidentEdge); assertThat(network.incidentNodes(incidentEdge)).contains(node); } for (String inEdge : network.inEdges(node)) { assertThat(network.incidentEdges(node)).contains(inEdge); assertThat(network.outEdges(network.incidentNodes(inEdge).adjacentNode(node))) .contains(inEdge); } for (String outEdge : network.outEdges(node)) { assertThat(network.incidentEdges(node)).contains(outEdge); assertThat(network.inEdges(network.incidentNodes(outEdge).adjacentNode(node))) .contains(outEdge); } for (Integer adjacentNode : network.adjacentNodes(node)) { assertTrue( network.predecessors(node).contains(adjacentNode) || network.successors(node).contains(adjacentNode)); assertTrue( !network.edgesConnecting(node, adjacentNode).isEmpty() || !network.edgesConnecting(adjacentNode, node).isEmpty()); } for (Integer predecessor : network.predecessors(node)) { assertThat(network.successors(predecessor)).contains(node); assertThat(network.edgesConnecting(predecessor, node)).isNotEmpty(); } for (Integer successor : network.successors(node)) { assertThat(network.predecessors(successor)).contains(node); assertThat(network.edgesConnecting(node, successor)).isNotEmpty(); } } }