@Override public boolean apply(E edge) { return incidentNodes(edge).adjacentNode(nodePresent).equals(nodeToCheck); } };
@Override public N apply(E edge) { return network.incidentNodes(edge).adjacentNode(node); } };
@Override public N apply(E edge) { return network.incidentNodes(edge).adjacentNode(node); } };
@Override public boolean apply(E edge) { return incidentNodes(edge).adjacentNode(nodePresent).equals(nodeToCheck); } };
@Override public boolean apply(E edge) { return incidentNodes(edge).adjacentNode(nodePresent).equals(nodeToCheck); } };
@Override public N apply(E edge) { return network.incidentNodes(edge).adjacentNode(node); } };
@Test public void testUnorderedEndpointPair() { EndpointPair<String> unordered = EndpointPair.unordered("chicken", "egg"); assertThat(unordered.isOrdered()).isFalse(); assertThat(unordered).containsExactly("chicken", "egg"); assertThat(ImmutableSet.of(unordered.nodeU(), unordered.nodeV())) .containsExactly("chicken", "egg"); assertThat(unordered.adjacentNode(unordered.nodeU())).isEqualTo(unordered.nodeV()); assertThat(unordered.adjacentNode(unordered.nodeV())).isEqualTo(unordered.nodeU()); assertThat(unordered.toString()).contains("chicken"); assertThat(unordered.toString()).contains("egg"); }
@Test public void testSelfLoop() { EndpointPair<String> unordered = EndpointPair.unordered("node", "node"); assertThat(unordered.isOrdered()).isFalse(); assertThat(unordered).containsExactly("node", "node"); assertThat(unordered.nodeU()).isEqualTo("node"); assertThat(unordered.nodeV()).isEqualTo("node"); assertThat(unordered.adjacentNode("node")).isEqualTo("node"); assertThat(unordered.toString()).isEqualTo("[node, node]"); }
@Test public void testOrderedEndpointPair() { EndpointPair<String> ordered = EndpointPair.ordered("source", "target"); assertThat(ordered.isOrdered()).isTrue(); assertThat(ordered).containsExactly("source", "target").inOrder(); assertThat(ordered.source()).isEqualTo("source"); assertThat(ordered.target()).isEqualTo("target"); assertThat(ordered.nodeU()).isEqualTo("source"); assertThat(ordered.nodeV()).isEqualTo("target"); assertThat(ordered.adjacentNode("source")).isEqualTo("target"); assertThat(ordered.adjacentNode("target")).isEqualTo("source"); assertThat(ordered.toString()).isEqualTo("<source -> target>"); }
/** * Returns the subgraph of {@code network} induced by {@code nodes}. This subgraph is a new graph * that contains all of the nodes in {@code nodes}, and all of the {@link Network#edges() edges} * from {@code network} for which the {@link Network#incidentNodes(Object) incident nodes} are * both contained by {@code nodes}. * * @throws IllegalArgumentException if any element in {@code nodes} is not a node in the graph */ public static <N, E> MutableNetwork<N, E> inducedSubgraph( Network<N, E> network, Iterable<? extends N> nodes) { MutableNetwork<N, E> subgraph = (nodes instanceof Collection) ? NetworkBuilder.from(network).expectedNodeCount(((Collection) nodes).size()).build() : NetworkBuilder.from(network).build(); for (N node : nodes) { subgraph.addNode(node); } for (N node : subgraph.nodes()) { for (E edge : network.outEdges(node)) { N successorNode = network.incidentNodes(edge).adjacentNode(node); if (subgraph.nodes().contains(successorNode)) { subgraph.addEdge(node, successorNode, edge); } } } return subgraph; }
@After public void validateSourceAndTarget() { for (Integer node : network.nodes()) { for (String inEdge : network.inEdges(node)) { EndpointPair<Integer> endpointPair = network.incidentNodes(inEdge); assertThat(endpointPair.source()).isEqualTo(endpointPair.adjacentNode(node)); assertThat(endpointPair.target()).isEqualTo(node); } for (String outEdge : network.outEdges(node)) { EndpointPair<Integer> endpointPair = network.incidentNodes(outEdge); assertThat(endpointPair.source()).isEqualTo(node); assertThat(endpointPair.target()).isEqualTo(endpointPair.adjacentNode(node)); } for (Integer adjacentNode : network.adjacentNodes(node)) { Set<String> edges = network.edgesConnecting(node, adjacentNode); Set<String> antiParallelEdges = network.edgesConnecting(adjacentNode, node); assertThat(node.equals(adjacentNode) || Collections.disjoint(edges, antiParallelEdges)) .isTrue(); } } }
@Test public void testAdjacentNode_nodeNotIncident() { ImmutableList<MutableNetwork<Integer, String>> testNetworks = ImmutableList.of( NetworkBuilder.directed().<Integer, String>build(), NetworkBuilder.undirected().<Integer, String>build()); for (MutableNetwork<Integer, String> network : testNetworks) { network.addEdge(1, 2, "1-2"); EndpointPair<Integer> endpointPair = network.incidentNodes("1-2"); try { endpointPair.adjacentNode(3); fail("Should have rejected adjacentNode() called with a node not incident to edge."); } catch (IllegalArgumentException expected) { } } }
/** * Returns the subgraph of {@code network} induced by {@code nodes}. This subgraph is a new graph * that contains all of the nodes in {@code nodes}, and all of the {@link Network#edges() edges} * from {@code network} for which the {@link Network#incidentNodes(Object) incident nodes} are * both contained by {@code nodes}. * * @throws IllegalArgumentException if any element in {@code nodes} is not a node in the graph */ public static <N, E> MutableNetwork<N, E> inducedSubgraph( Network<N, E> network, Iterable<? extends N> nodes) { MutableNetwork<N, E> subgraph = (nodes instanceof Collection) ? NetworkBuilder.from(network).expectedNodeCount(((Collection) nodes).size()).build() : NetworkBuilder.from(network).build(); for (N node : nodes) { subgraph.addNode(node); } for (N node : subgraph.nodes()) { for (E edge : network.outEdges(node)) { N successorNode = network.incidentNodes(edge).adjacentNode(node); if (subgraph.nodes().contains(successorNode)) { subgraph.addEdge(node, successorNode, edge); } } } return subgraph; }
private static class TransposedNetwork<N, E> extends ForwardingNetwork<N, E> { private final Network<N, E> network; TransposedNetwork(Network<N, E> network) { this.network = network; } @Override protected Network<N, E> delegate() { return network; } @Override public Set<N> predecessors(N node) { return delegate().successors(node); // transpose } @Override public Set<N> successors(N node) { return delegate().predecessors(node); // transpose } @Override public int inDegree(N node) { return delegate().outDegree(node); // transpose } @Override public int outDegree(N node) { return delegate().inDegree(node); // transpose
assertThat(network.outEdges(network.incidentNodes(inEdge).adjacentNode(node))) .contains(inEdge); if (network.isDirected()) { assertThat(network.inEdges(network.incidentNodes(outEdge).adjacentNode(node))) .contains(outEdge); if (network.isDirected()) {
@Override public boolean apply(E edge) { return incidentNodes(edge).adjacentNode(nodePresent).equals(nodeToCheck); } };
@Override public N apply(E edge) { return network.incidentNodes(edge).adjacentNode(node); } };
@Override public boolean apply(E edge) { return incidentNodes(edge).adjacentNode(nodePresent).equals(nodeToCheck); } };
@Test public void testUnorderedEndpointPair() { EndpointPair<String> unordered = EndpointPair.unordered("chicken", "egg"); assertThat(unordered.isOrdered()).isFalse(); assertThat(unordered).containsExactly("chicken", "egg"); assertThat(ImmutableSet.of(unordered.nodeU(), unordered.nodeV())) .containsExactly("chicken", "egg"); assertThat(unordered.adjacentNode(unordered.nodeU())).isEqualTo(unordered.nodeV()); assertThat(unordered.adjacentNode(unordered.nodeV())).isEqualTo(unordered.nodeU()); assertThat(unordered.toString()).contains("chicken"); assertThat(unordered.toString()).contains("egg"); }
@Test public void testSelfLoop() { EndpointPair<String> unordered = EndpointPair.unordered("node", "node"); assertThat(unordered.isOrdered()).isFalse(); assertThat(unordered).containsExactly("node", "node"); assertThat(unordered.nodeU()).isEqualTo("node"); assertThat(unordered.nodeV()).isEqualTo("node"); assertThat(unordered.adjacentNode("node")).isEqualTo("node"); assertThat(unordered.toString()).isEqualTo("[node, node]"); }