public Set<E> getAllEdges(V sourceVertex, V targetVertex) {
Set<E> res = new HashSet<E>();
if (g1.containsVertex(sourceVertex) && g1.containsVertex(targetVertex)) {
res.addAll(g1.getAllEdges(sourceVertex, targetVertex));
}
if (g2.containsVertex(sourceVertex) && g2.containsVertex(targetVertex)) {
res.addAll(g2.getAllEdges(sourceVertex, targetVertex));
}
return Collections.unmodifiableSet(res);
}
public Set<E> outgoingEdgesOf(V vertex) {
Set<E> res = new HashSet<E>();
if (getG1().containsVertex(vertex)) {
res.addAll(getG1().outgoingEdgesOf(vertex));
}
if (getG2().containsVertex(vertex)) {
res.addAll(getG2().outgoingEdgesOf(vertex));
}
return Collections.unmodifiableSet(res);
}
public Set<E> edgesOf(V vertex) {
Set<E> res = new HashSet<E>();
if (g1.containsVertex(vertex)) {
res.addAll(g1.edgesOf(vertex));
}
if (g2.containsVertex(vertex)) {
res.addAll(g2.edgesOf(vertex));
}
return Collections.unmodifiableSet(res);
}
/**
* Finds the vertex set for the subgraph of all cycles.
*
* @return set of all vertices which participate in at least one cycle in this graph
*/
public Set<V> findCycles() {
// ProbeIterator can't be used to handle this case,
// so use StrongConnectivityInspector instead.
StrongConnectivityInspector<V, E> inspector = new StrongConnectivityInspector<V, E>(graph);
List<Set<V>> components = inspector.stronglyConnectedSets();
// A vertex participates in a cycle if either of the following is
// true: (a) it is in a component whose size is greater than 1
// or (b) it is a self-loop
Set<V> set = new HashSet<V>();
for (Set<V> component : components) {
if (component.size() > 1) {
// cycle
set.addAll(component);
} else {
V v = component.iterator().next();
if (graph.containsEdge(v, v)) {
// self-loop
set.add(v);
}
}
}
return set;
}
/**
* Compute the unique decomposition of the input graph G (atoms of G). Implementation of algorithm
* Atoms as described in Berry et al. (2010), DOI:10.3390/a3020197, <a
* href="http://www.mdpi.com/1999-4893/3/2/197">http://www.mdpi.com/1999-4893/3/2/197</a>
*/
private void computeAtoms() {
if (chordalGraph == null) {
computeMinimalTriangulation();
}
separators = new HashSet<>();
// initialize g' as subgraph of graph (same vertices and edges)
UndirectedGraph<V, E> gprime = copyAsSimpleGraph(graph);
// initialize h' as subgraph of chordalGraph (same vertices and edges)
UndirectedGraph<V, E> hprime = copyAsSimpleGraph(chordalGraph);
atoms = new HashSet<>();
Iterator<V> iterator = meo.descendingIterator();
while (iterator.hasNext()) {
V v = iterator.next();
if (generators.contains(v)) {
Set<V> separator = new HashSet<>(Graphs.neighborListOf(hprime, v));
if (isClique(graph, separator)) {
if (separator.size() > 0) {
if (separators.contains(separator)) {
fullComponentCount.put(separator, fullComponentCount.get(separator) + 1);
} else {
fullComponentCount.put(separator, 2);
separators.add(separator);
}
}
UndirectedGraph<V, E> tmpGraph = copyAsSimpleGraph(gprime);
tmpGraph.removeAllVertices(separator);
ConnectivityInspector<V, E> con = new ConnectivityInspector<>(tmpGraph);
if (con.isGraphConnected()) {
throw new RuntimeException("separator did not separate the graph");
}
for (Set<V> component : con.connectedSets()) {
if (component.contains(v)) {
gprime.removeAllVertices(component);
component.addAll(separator);
atoms.add(new HashSet<>(component));
assert (component.size() > 0);
break;
}
}
}
}
hprime.removeVertex(v);
}
if (gprime.vertexSet().size() > 0) {
atoms.add(new HashSet<>(gprime.vertexSet()));
}
}
public Set<V> vertexSet() {
Set<V> res = new HashSet<V>();
res.addAll(g1.vertexSet());
res.addAll(g2.vertexSet());
return Collections.unmodifiableSet(res);
}
public Set<E> edgeSet() {
Set<E> res = new HashSet<E>();
res.addAll(g1.edgeSet());
res.addAll(g2.edgeSet());
return Collections.unmodifiableSet(res);
}