@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build(); }
/** Creates a mutable copy of {@code network} with the same nodes and edges. */ public static <N, E> MutableNetwork<N, E> copyOf(Network<N, E> network) { MutableNetwork<N, E> copy = NetworkBuilder.from(network) .expectedNodeCount(network.nodes().size()) .expectedEdgeCount(network.edges().size()) .build(); for (N node : network.nodes()) { copy.addNode(node); } for (E edge : network.edges()) { EndpointPair<N> endpointPair = network.incidentNodes(edge); copy.addEdge(endpointPair.nodeU(), endpointPair.nodeV(), edge); } return copy; }
@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.directed().allowsSelfLoops(true).build(); }
@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.undirected().allowsSelfLoops(true).build(); }
/** * Returns a {@link NetworkBuilder} initialized with all properties queryable from {@code * network}. * * <p>The "queryable" properties are those that are exposed through the {@link Network} interface, * such as {@link Network#isDirected()}. Other properties, such as {@link * #expectedNodeCount(int)}, are not set in the new builder. */ public static <N, E> NetworkBuilder<N, E> from(Network<N, E> network) { return new NetworkBuilder<N, E>(network.isDirected()) .allowsParallelEdges(network.allowsParallelEdges()) .allowsSelfLoops(network.allowsSelfLoops()) .nodeOrder(network.nodeOrder()) .edgeOrder(network.edgeOrder()); }
@Test public void createDirected_multigraph() { MutableNetwork<Integer, String> directedMultigraph = NetworkBuilder.directed().allowsParallelEdges(true).build(); assertThat(directedMultigraph.addEdge(N1, N2, E12)).isTrue(); assertThat(directedMultigraph.addEdge(N1, N2, E12_A)).isTrue(); assertThat(directedMultigraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12, E12_A)); assertThat(directedMultigraph.edgesConnecting(N2, N1)).isEmpty(); }
/** * 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; }
/** * Returns an empty {@link MutableCTree} with the properties of this {@link TreeNetworkBuilder}. */ // TODO(jrtom): decide how we're going to handle different implementations. // For the graph stuff, we don't really need different implementations, but // for trees, maybe we do; at least for binary trees vs. trees with no restrictions on outgoing edges... public <N1 extends N, E1 extends E> MutableCTreeNetwork<N1, E1> build() { NetworkBuilder<Object, Object> graphBuilder = NetworkBuilder.directed().allowsSelfLoops(false).allowsParallelEdges(false); if (expectedNodeCount.isPresent()) { graphBuilder = graphBuilder.expectedNodeCount(expectedNodeCount.get()); } MutableNetwork<N1, E1> delegate = graphBuilder.nodeOrder(nodeOrder).edgeOrder(edgeOrder).build(); @SuppressWarnings("unchecked") Optional<N1> rootCast = (Optional<N1>) root; return new DelegateCTreeNetwork<N1, E1>(delegate, rootCast); }
@Test public void equivalent_propertiesDiffer() { network.addEdge(N1, N2, E12); MutableNetwork<Integer, String> g2 = NetworkBuilder.from(network) .allowsParallelEdges(!network.allowsParallelEdges()) .allowsSelfLoops(!network.allowsSelfLoops()) .build(); g2.addEdge(N1, N2, E12); assertThat(network).isEqualTo(g2); }
@Test public void nodeOrderUnorderedandEdgesSorted() { MutableNetwork<Integer, String> network = NetworkBuilder.directed() .nodeOrder(unordered()) .edgeOrder(ElementOrder.sorted(Ordering.<String>natural().reverse())) .build(); addEdges(network); assertThat(network.edgeOrder()) .isEqualTo(ElementOrder.sorted(Ordering.<String>natural().reverse())); assertThat(network.edges()).containsExactly("p", "i", "e").inOrder(); assertThat(network.nodeOrder()).isEqualTo(unordered()); assertThat(network.nodes()).containsExactly(4, 1, 3); }
@Test public void equivalent_edgeAddOrdersDiffer() { NetworkBuilder<Integer, String> builder = NetworkBuilder.from(network).allowsParallelEdges(true); MutableNetwork<Integer, String> g1 = builder.build(); MutableNetwork<Integer, String> g2 = builder.build(); // for ug1, add e12 first, then e12_a g1.addEdge(N1, N2, E12); g1.addEdge(N1, N2, E12_A); // for ug2, add e12_a first, then e12 g2.addEdge(N1, N2, E12_A); g2.addEdge(N1, N2, E12); assertThat(g1).isEqualTo(g2); }
@Test public void createDirected_expectedNodeCount() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().expectedNodeCount(NODE_COUNT).build(); assertThat(directedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(directedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(directedGraph.edgesConnecting(N2, N1)).isEmpty(); }
directed ? NetworkBuilder.directed() : NetworkBuilder.undirected(); MutableNetwork<N, E> graph = builder.expectedNodeCount(node_count).expectedEdgeCount(edge_count).build();
@Test public void createDirected_expectedEdgeCount() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().expectedEdgeCount(EDGE_COUNT).build(); assertThat(directedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(directedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(directedGraph.edgesConnecting(N2, N1)).isEmpty(); }
@Test public void createUndirected_multigraph() { MutableNetwork<Integer, String> undirectedMultigraph = NetworkBuilder.undirected().allowsParallelEdges(true).build(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12)).isTrue(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12_A)).isTrue(); assertThat(undirectedMultigraph.addEdge(N2, N1, E21)).isTrue(); assertThat(undirectedMultigraph.edgesConnecting(N1, N2)) .isEqualTo(ImmutableSet.of(E12, E12_A, E21)); }
networkBuilder.allowsParallelEdges(true).allowsSelfLoops(true).build();
@Test public void createUndirected_expectedNodeCount() { MutableNetwork<Integer, String> undirectedGraph = NetworkBuilder.undirected().expectedNodeCount(NODE_COUNT).build(); assertThat(undirectedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(undirectedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(undirectedGraph.edgesConnecting(N2, N1)).isEqualTo(ImmutableSet.of(E12)); }
@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) { } } }