public static Iterator<FlowElement> getReverseTopologicalIterator( ElementGraph graph ) { return new TopologicalOrderIterator<>( new EdgeReversedGraph<>( directed( graph ) ) ); }
/** * @see java.lang.Object#toString() */ @Override public String toString() { return toStringFromSets(vertexSet(), edgeSet(), getType().isDirected()); } }
/** * Get the ancestors of a vertex. * * @param vertex the vertex to get the ancestors of * @return {@link Set} of ancestors of a vertex */ public Set<V> getAncestors(V vertex) { EdgeReversedGraph<V, E> reversedGraph = new EdgeReversedGraph<>(this); Iterator<V> iterator = new DepthFirstIterator<>(reversedGraph, vertex); Set<V> ancestors = new HashSet<>(); // Do not add start vertex to result. if (iterator.hasNext()) { iterator.next(); } iterator.forEachRemaining(ancestors::add); return ancestors; }
/** * */ @Override public Set<Equivalences<T>> getSub(Equivalences<T> v) { Set<Equivalences<T>> result = cacheSub.get(v); if (result == null) { result = new LinkedHashSet<>(); BreadthFirstIterator<Equivalences<T>, DefaultEdge> iterator = new BreadthFirstIterator<Equivalences<T>, DefaultEdge>( new EdgeReversedGraph<>(dag), v); while (iterator.hasNext()) { Equivalences<T> child = iterator.next(); result.add(child); } result = Collections.unmodifiableSet(result); cacheSub.put(v, result); } return result; }
/** * */ @Override public Set<Equivalences<T>> getSub(Equivalences<T> v) { Set<Equivalences<T>> result = cacheSub.get(v); if (result == null) { result = new LinkedHashSet<>(); BreadthFirstIterator<Equivalences<T>, DefaultEdge> iterator = new BreadthFirstIterator<Equivalences<T>, DefaultEdge>( new EdgeReversedGraph<>(dag), v); while (iterator.hasNext()) { Equivalences<T> child = iterator.next(); result.add(child); } result = Collections.unmodifiableSet(result); cacheSub.put(v, result); } return result; }
public static <Node, G extends Graph> Iterator<Node> getNodeIterator( SearchOrder searchOrder, G graph ) { if( searchOrder == null ) return new TopologicalOrderIterator( graph ); // faster than getVertexSet().iterator() Node node = null; if( graph.containsVertex( Extent.head ) ) { if( !searchOrder.isReversed() ) node = (Node) Extent.head; else node = (Node) Extent.tail; } switch( searchOrder ) { case Depth: return new DepthFirstIterator( graph, node ); case Breadth: return new BreadthFirstIterator( graph, node ); case Topological: return new TopologicalOrderIterator( graph ); // TODO: uses a equality based hashmap internally, will fail if relying on identity case ReverseDepth: return new DepthFirstIterator( new EdgeReversedGraph( graph ), node ); case ReverseBreadth: return new BreadthFirstIterator( new EdgeReversedGraph( graph ), node ); case ReverseTopological: return new TopologicalOrderIterator( new EdgeReversedGraph( graph ) ); // TODO: uses a equality based hashmap internally, will fail if relying on identity } throw new IllegalStateException( "unknown order: " + searchOrder ); } }
/** * */ @Override public Set<T> getSubRepresentatives(T v) { Equivalences<T> eq = vertexIndex.get(v); if (eq == null) return Collections.singleton(v); Set<T> result = cacheSubRep.get(eq.getRepresentative()); if (result == null) { result = new LinkedHashSet<T>(); BreadthFirstIterator<Equivalences<T>, DefaultEdge> iterator = new BreadthFirstIterator<Equivalences<T>, DefaultEdge>( new EdgeReversedGraph<>(dag), eq); while (iterator.hasNext()) { Equivalences<T> child = iterator.next(); result.add(child.getRepresentative()); } result = Collections.unmodifiableSet(result); cacheSubRep.put(eq.getRepresentative(), result); } return result; }
/** * */ @Override public Set<T> getSubRepresentatives(T v) { Equivalences<T> eq = vertexIndex.get(v); if (eq == null) return Collections.singleton(v); Set<T> result = cacheSubRep.get(eq.getRepresentative()); if (result == null) { result = new LinkedHashSet<T>(); BreadthFirstIterator<Equivalences<T>, DefaultEdge> iterator = new BreadthFirstIterator<Equivalences<T>, DefaultEdge>( new EdgeReversedGraph<>(dag), eq); while (iterator.hasNext()) { Equivalences<T> child = iterator.next(); result.add(child.getRepresentative()); } result = Collections.unmodifiableSet(result); cacheSubRep.put(eq.getRepresentative(), result); } return result; }
/** * Performs a Dijkstra search from each source to the given target by * reversing the graph and using a {@link #oneToMany} from the target * to all the sources. If the graph is undirected, there is no need * to reverse the graph. * * @param sources Sources * @param target Target * @return A map of the distance to the target keyed by the source vertex. */ public Map<V, Double> manyToOne(final Set<V> sources, V target) { if (sources.isEmpty()) { throw new IllegalArgumentException( "Please specify at least one source."); } else { // For directed graphs, we simply reverse the graph and do a // oneToMany from the target. if (graph instanceof DirectedGraph) { EdgeReversedGraph<V, E> reversedGraph = new EdgeReversedGraph<V, E>((DirectedGraph) graph); return new Dijkstra<V, E>(reversedGraph) .oneToMany(target, sources); } // For undirected graphs, there is no need to reverse the graph. else { return oneToMany(target, sources); } } }
Graph<V, E> inverseGraph = new EdgeReversedGraph<V, E>(graph);
public List<String> getOrderedSuperclasses(String className) { String classNameWithDots = ResourceList.getClassNameFromResourcePath(className); if (!inheritanceGraph.containsVertex(classNameWithDots)) { LoggingUtils.logWarnAtMostOnce(logger, "Class not in inheritance graph: " + classNameWithDots); return new LinkedList<>(); } EdgeReversedGraph<String, DefaultEdge> reverseGraph = new EdgeReversedGraph<String, DefaultEdge>( inheritanceGraph); List<String> orderedList = new LinkedList<>(); BreadthFirstIterator<String, DefaultEdge> bfi = new BreadthFirstIterator<String, DefaultEdge>( reverseGraph, classNameWithDots); while (bfi.hasNext()) { orderedList.add(bfi.next()); } return orderedList; }
public Set<String> getSuperclasses(String className) { String classNameWithDots = ResourceList.getClassNameFromResourcePath(className); if (!inheritanceGraph.containsVertex(classNameWithDots)) { LoggingUtils.logWarnAtMostOnce(logger, "Class not in inheritance graph: " + classNameWithDots); return new LinkedHashSet<>(); } EdgeReversedGraph<String, DefaultEdge> reverseGraph = new EdgeReversedGraph<String, DefaultEdge>( inheritanceGraph); // TreeSet so that classes are sorted by name and thus deterministic across platforms Set<String> result = new TreeSet<>(); BreadthFirstIterator<String, DefaultEdge> bfi = new BreadthFirstIterator<String, DefaultEdge>( reverseGraph, classNameWithDots); while (bfi.hasNext()) { result.add(bfi.next()); } return result; }
Graph<V, DefaultEdge> gd = new EdgeReversedGraph<>(dg); Set<V> subset2 = new HashSet<>(); unmatched2.stream().map((v) -> {
/** * IMPORTANT: Only provides an edge reverse view, does not change the edges themselves * @param nfa * @return */ public static <V, E> Nfa<V, E> reverse(Nfa<V, E> nfa) { EdgeReversedGraph<V, E> g = new EdgeReversedGraph<>(nfa.getGraph()); NfaImpl<V, E> result = new NfaImpl<>(g, nfa.getEndStates(), nfa.getStartStates()); return result; }
/** * Compute all distances to and from a landmark * * @param landmark the landmark */ private void precomputeToFromLandmark(V landmark) { // compute distances from landmark SingleSourcePaths<V, E> fromLandmarkPaths = new DijkstraShortestPath<>(graph).getPaths(landmark); Map<V, Double> fromLandMarkDistances = new HashMap<>(); for (V v : graph.vertexSet()) { fromLandMarkDistances.put(v, fromLandmarkPaths.getWeight(v)); } fromLandmark.put(landmark, fromLandMarkDistances); // compute distances to landmark (using reverse graph) if (directed) { Graph<V, E> reverseGraph = new EdgeReversedGraph<>(graph); SingleSourcePaths<V, E> toLandmarkPaths = new DijkstraShortestPath<>(reverseGraph).getPaths(landmark); Map<V, Double> toLandMarkDistances = new HashMap<>(); for (V v : graph.vertexSet()) { toLandMarkDistances.put(v, toLandmarkPaths.getWeight(v)); } toLandmark.put(landmark, toLandMarkDistances); } }
private <T> Map<T, SemanticIndexRange> createSemanticIndex(EquivalencesDAG<T> dag) { DirectedGraph<T, DefaultEdge> namedDag = getNamedDAG(dag); // reverse the named dag so that we give smallest indexes to ? DirectedGraph<T, DefaultEdge> reversed = new EdgeReversedGraph<>(namedDag); LinkedList<T> roots = new LinkedList<>(); for (T n : reversed.vertexSet()) if ((reversed.incomingEdgesOf(n)).isEmpty()) roots.add(n); Map<T,SemanticIndexRange> ranges = new HashMap<>(); for (T root: roots) { // depth-first sort GraphIterator<T, DefaultEdge> orderIterator = new DepthFirstIterator<>(reversed, root); // add Listener to create the ranges orderIterator.addTraversalListener(new SemanticIndexer<T>(reversed, ranges)); // System.out.println("\nIndexing:"); while (orderIterator.hasNext()) orderIterator.next(); } return ranges; }
EdgeReversedGraph<OWLClass, DefaultWeightedEdge> reversedForest = new EdgeReversedGraph<OWLClass, DefaultWeightedEdge>(existentialRestrictionGraph); TopologicalOrderIterator<OWLClass, DefaultWeightedEdge> bottomUpIt = new TopologicalOrderIterator<OWLClass, DefaultWeightedEdge>(reversedForest); while (bottomUpIt.hasNext()) {
ServiceTree convertFrom(final ServiceDAG serviceDAG) { final IServiceDAGVertex<?> applicationVertex = serviceDAG.findVertex(APPLICATION_VERTEX_KEY).get(); final ServiceTree serviceTree = new ServiceTree(applicationVertex); // Reverse the edges of the service graph before we perform our walk. // We do this because the service graph is built with the root vertex // at the bottom. And this moves it to the top. final DirectedGraph<IServiceDAGVertex<?>,DefaultEdge> reversedGraph = new EdgeReversedGraph<>(serviceDAG); final TopologicalOrderIterator<IServiceDAGVertex<?>, DefaultEdge> topoOrder = new TopologicalOrderIterator<>(reversedGraph); // Walk the graph in topographical order and use the tree conversion listener // to convert the DAG into a tree final ServiceTreeConversionListener listener = new ServiceTreeConversionListener(applicationVertex, serviceTree, reversedGraph); topoOrder.addTraversalListener(listener); while (topoOrder.hasNext()) { topoOrder.next(); } return serviceTree; }
EdgeReversedGraph<OWLClass, DefaultWeightedEdge> reversedForest = new EdgeReversedGraph<OWLClass, DefaultWeightedEdge>(existentialRestrictionGraph); TopologicalOrderIterator<OWLClass, DefaultWeightedEdge> bottomUpIt = new TopologicalOrderIterator<OWLClass, DefaultWeightedEdge>(reversedForest); while (bottomUpIt.hasNext()) {
final EdgeReversedGraph<OWLClass, DefaultWeightedEdge> reversedForest = new EdgeReversedGraph<>(existentialRestrictionGraph); final TopologicalOrderIterator<OWLClass, DefaultWeightedEdge> bottomUpIt = new TopologicalOrderIterator<>(reversedForest); while (bottomUpIt.hasNext())