/** * Recursive DFS algorthm * * @param matrix Map of lists representing adj matrix * @param info Map of nodes representing node info * @param v Node source * @param n int number of nodes in graph * @param: print boolean if to print node during traversal * @return List of nodes in order visited */ public ArrayList<String> dfs_rec( Map<Integer, List<Integer>> matrix, Map<Integer, GraphNode> info, GraphNode v, Integer n, boolean print, ArrayList<String> ops) { v.setVisited(true); if (print) System.out.println(v); ops.add(v.toString()); // if(checkStoppingCondition(v, getN())) { // return; // } List<Integer> edgeTarget = matrix.get(v.getID()); for (int i = 0; i < edgeTarget.size(); ++i) { if (edgeTarget.get(i) == 1) { GraphNode node = info.get(i + 1); if (!node.getVisited()) { return dfs_rec(matrix, info, node, n, print, ops); } } } return ops; }
public static void saveGraph(Graph g, File f) throws FileNotFoundException, SecurityException { ArrayList<GraphEdge> edgemarks = new ArrayList<GraphEdge>(); PrintStream p = new PrintStream(new FileOutputStream(f)); try { Iterator<GraphNode> n = g.getNodeIterator(); int count = 1; while (n.hasNext()) { GraphNode node = n.next(); ListIterator<GraphEdge> e = node.getEdgeIterator(); while (e.hasNext()) { GraphEdge edge = e.next(); if (g.getNodeById(edge.getTarget().getId()) == null) { e.remove(); continue; } if (!edgemarks.contains(edge)) p.println( "" + (node.getId() + 1) + " " + (edge.getTarget().getId() + 1) + " " + edge.getWeight()); edgemarks.add(edge.getTarget().getEdgeByTargetId(node.getId())); edgemarks.add(edge); } if (count % 100 == 0) System.out.println("Saving. . ." + count++); } } finally { p.close(); } }
/** * 利用广度优先搜索进行路径判断 p -> q 是否有路径 * * @return */ private static boolean pathOrderCheckBFS(GraphNode<Integer> p, GraphNode<Integer> q) { IQueue<GraphNode<Integer>> queue = new Queue<GraphNode<Integer>>(); if (!p.visited && p.equals(q)) { return true; } p.visited = true; queue.enqueue(p); while (!queue.isEmpty()) { List<GraphNode<Integer>> neighbors = queue.dequeue().neighborList; for (int i = 0; i < neighbors.size(); i++) { GraphNode<Integer> neighbor = neighbors.get(i); if (!neighbor.visited && neighbor.equals(q)) { return true; } neighbor.visited = true; queue.enqueue(neighbor); } } return false; }
/** * Returns the nodes of a particular stroke that are found in the cycle * * @param s stroke * @return nodes that belong to that stroke */ public List<GraphNode> getNodesOfStroke(Stroke s) { List<GraphNode> nodes = new ArrayList<GraphNode>(); for (GraphNode n : this) { if (n.getStroke().equals(s)) nodes.add(n); } return nodes; }
private void computeDependencies(List<GraphNode<T>> nodes) { List<GraphNode<T>> nextNodesToDisplay = null; for (GraphNode<T> node : nodes) { if (!isAlreadyEvaluated(node)) { List<GraphNode<T>> comingInNodes = node.getComingInNodes(); if (areAlreadyEvaluated(comingInNodes)) { listener.evaluating(node.value); evaluatedNodes.add(node); List<GraphNode<T>> goingOutNodes = node.getGoingOutNodes(); if (goingOutNodes != null) { if (nextNodesToDisplay == null) nextNodesToDisplay = new ArrayList<GraphNode<T>>(); // add these too, so they get a chance to be displayed // as well nextNodesToDisplay.addAll(goingOutNodes); } } else { if (nextNodesToDisplay == null) nextNodesToDisplay = new ArrayList<GraphNode<T>>(); // the checked node should be carried nextNodesToDisplay.add(node); } } } if (nextNodesToDisplay != null) { computeDependencies(nextNodesToDisplay); } // here the recursive call ends }
/** * Returns a string like 'source -> destination' * * @return String */ public String toString() { StringBuffer buffer = new StringBuffer("GraphModelConnection: "); buffer.append(sourceNode != null ? sourceNode.getText() : "null"); buffer.append(isDirected() ? " --> " : " --- "); buffer.append(destinationNode != null ? destinationNode.getText() : "null"); buffer.append(" (weight=").append(getWeightInLayout()).append(")"); return buffer.toString(); }
/** * Get the strokes found in the cycle * * @return list of strokes found */ public List<Stroke> getStrokes() { List<Stroke> list = new ArrayList<Stroke>(); for (GraphNode n : this) { if (!list.contains(n.getStroke())) list.add(n.getStroke()); } return orderStrokes(list); }
private static void relax(GraphEdge e) { GraphNode v = e.from, w = e.to; if (w.minimumDistance < v.minimumDistance + 1) { w.minimumDistance = v.minimumDistance + 1; w.previous = v; } }
protected void nodeStmt(StreamTokenizer tk, final int nindex) throws Exception { tk.nextToken(); GraphNode temp = m_nodes.get(nindex); if (tk.ttype == ']' || tk.ttype == StreamTokenizer.TT_EOF) { return; } else if (tk.ttype == StreamTokenizer.TT_WORD) { if (tk.sval.equalsIgnoreCase("label")) { tk.nextToken(); if (tk.ttype == '=') { tk.nextToken(); if (tk.ttype == StreamTokenizer.TT_WORD || tk.ttype == '"') { temp.lbl = tk.sval; } else { System.err.println("couldn't find label at line " + tk.lineno()); tk.pushBack(); } } else { System.err.println("couldn't find label at line " + tk.lineno()); tk.pushBack(); } } else if (tk.sval.equalsIgnoreCase("color")) { tk.nextToken(); if (tk.ttype == '=') { tk.nextToken(); if (tk.ttype == StreamTokenizer.TT_WORD || tk.ttype == '"') {; } else { System.err.println("couldn't find color at line " + tk.lineno()); tk.pushBack(); } } else { System.err.println("couldn't find color at line " + tk.lineno()); tk.pushBack(); } } else if (tk.sval.equalsIgnoreCase("style")) { tk.nextToken(); if (tk.ttype == '=') { tk.nextToken(); if (tk.ttype == StreamTokenizer.TT_WORD || tk.ttype == '"') {; } else { System.err.println("couldn't find style at line " + tk.lineno()); tk.pushBack(); } } else { System.err.println("couldn't find style at line " + tk.lineno()); tk.pushBack(); } } } nodeStmt(tk, nindex); }
private double getPMulticluster(List<List<Integer>> clusters, int numRestarts) { if (false) { Graph g = new EdgeListGraph(); List<Node> latents = new ArrayList<Node>(); for (int i = 0; i < clusters.size(); i++) { GraphNode latent = new GraphNode("L" + i); latent.setNodeType(NodeType.LATENT); latents.add(latent); g.addNode(latent); List<Node> cluster = variablesForIndices(clusters.get(i)); for (int j = 0; j < cluster.size(); j++) { g.addNode(cluster.get(j)); g.addDirectedEdge(latent, cluster.get(j)); } } SemPm pm = new SemPm(g); // pm.fixOneLoadingPerLatent(); SemOptimizerPowell semOptimizer = new SemOptimizerPowell(); semOptimizer.setNumRestarts(numRestarts); SemEstimator est = new SemEstimator(cov, pm, semOptimizer); est.setScoreType(SemIm.ScoreType.Fgls); est.estimate(); return est.getEstimatedSem().getPValue(); } else { double max = Double.NEGATIVE_INFINITY; for (int i = 0; i < numRestarts; i++) { Mimbuild2 mimbuild = new Mimbuild2(); List<List<Node>> _clusters = new ArrayList<List<Node>>(); for (List<Integer> _cluster : clusters) { _clusters.add(variablesForIndices(_cluster)); } List<String> names = new ArrayList<String>(); for (int j = 0; j < clusters.size(); j++) { names.add("L" + j); } mimbuild.search(_clusters, names, cov); double c = mimbuild.getpValue(); if (c > max) max = c; } return max; } }
/** * 利用广度优先搜索进行路径判断 p - q 之间是否有路径 * * @param p * @param q * @return */ public static boolean pathCheckBFS(GraphNode<Integer> p, GraphNode<Integer> q) { boolean isFound = false; p.restoreVisited(); isFound |= pathOrderCheckBFS(p, q); q.restoreVisited(); isFound |= pathOrderCheckBFS(q, p); return isFound; }
/** Validate that each node has been colored and connected nodes have different coloring. */ private static <N, E> void validateColoring(Graph<N, E> graph) { for (GraphNode<N, E> node : graph.getNodes()) { assertNotNull(node.getAnnotation()); } for (GraphEdge<N, E> edge : graph.getEdges()) { Color c1 = edge.getNodeA().getAnnotation(); Color c2 = edge.getNodeB().getAnnotation(); assertNotNull(c1); assertNotNull(c2); assertThat(c1.equals(c2)).isFalse(); } }
/** * Tests constructor CutFreeTextAction(freeTextGraphNode, clipboard) if freeTextGraphNode contains * a semanticModel attribute, but not SimpleSemanticModelElement object. IllegalArgumentException * is expected. */ public void testCtorIfFreeTextNodeContainInvalidSemanticModelAttribute() { try { freeTextGraphNode.addContained(new TextElement()); freeTextGraphNode.setSemanticModel(new Uml1SemanticModelBridge()); new CutFreeTextAction(freeTextGraphNode, null); fail( "IllegalArgumentException is expected because freeTextGraphNode contains invalid semanticModel" + "attribute (non-SimpleSemanticModelElement object)."); } catch (IllegalArgumentException e) { // success } }
public void computeDependencies() { List<GraphNode<T>> orphanNodes = getOrphanNodes(); List<GraphNode<T>> nextNodesToDisplay = new ArrayList<GraphNode<T>>(); if (orphanNodes != null) { for (GraphNode<T> node : orphanNodes) { listener.evaluating(node.value); evaluatedNodes.add(node); nextNodesToDisplay.addAll(node.getGoingOutNodes()); } computeDependencies(nextNodesToDisplay); } }
/** * An edge for the dynamic graph * * @param info - the info contained in the edge * @param weight - the weight of the edge * @param fromNode - the origin node of the edge * @param toNode - the end node of the edge */ public GraphEdge( EdgeType info, double weight, GraphNode<NodeType, EdgeType> fromNode, GraphNode<NodeType, EdgeType> toNode) { _fromNode = fromNode; _toNode = toNode; _info = info; _weight = weight; fromNode.addOutgoingEdge(this); toNode.addIncomingEdge(this); }
private List<GraphNode<T>> getOrphanNodes() { List<GraphNode<T>> orphanNodes = null; Set<T> keys = nodes.keySet(); for (T key : keys) { GraphNode<T> node = nodes.get(key); if (node.getComingInNodes() == null) { if (orphanNodes == null) orphanNodes = new ArrayList<GraphNode<T>>(); orphanNodes.add(node); } } return orphanNodes; }
/** * Tests method copyToClipboard(node, clipboard) if node is null. IllegalArgumentException is * expected * * @throws Exception exception */ public void testCopyToClipboardIfNodeNull() throws Exception { SimpleSemanticModelElement semanticModelBridge = new SimpleSemanticModelElement(); semanticModelBridge.setTypeInfo("FreeText"); freeTextGraphNode.setSemanticModel(semanticModelBridge); freeTextGraphNode.addContained(new TextElement()); CutFreeTextActionExt cutFreeTextAction = new CutFreeTextActionExt(freeTextGraphNode, null); try { cutFreeTextAction.copyToClipboard(null, null); fail("IllegalArgumentException is expected because node cannot be null."); } catch (IllegalArgumentException e) { // success } }
public LinkedList<String> getTree(GraphNode graph, String tabname) { List<?> elementsTree = trees.get(tabname); LinkedList<String> tree = new LinkedList<String>(); if (elementsTree == null) return tree; for (Object o : elementsTree) { if (o instanceof String) { String pathElem = jrds.Util.parseTemplate((String) o, graph.getProbe(), this, graph.getProbe().getHost()); tree.add(pathElem); } else if (o instanceof PathElement) tree.add(((PathElement) o).resolve(graph)); } return tree; }
/* * (non-Javadoc) * * @see java.util.AbstractSet#equals(java.lang.Object) */ @Override public boolean equals(Object o) { if (o instanceof GraphCycle) { GraphCycle gc = (GraphCycle) o; if (gc.size() != size()) return false; for (int i = 0; i < size(); i++) { GraphNode n1 = (GraphNode) toArray()[i]; GraphNode n2 = (GraphNode) gc.toArray()[i]; if (!n1.equals(n2)) return false; } return true; } return false; }
/** * Tests constructor CutFreeTextAction(freeTextGraphNode, clipboard) if freeTextGraphNode contains * a semanticModel attribute (SimpleSemanticModelElement object), but its typeInfo attribute is * not equal to "FreeText". IllegalArgumentException is expected. */ public void testCtorITypeInfoInvalid() { try { freeTextGraphNode.addContained(new TextElement()); SimpleSemanticModelElement semanticModelBridge = new SimpleSemanticModelElement(); semanticModelBridge.setTypeInfo("invalid_type_info"); freeTextGraphNode.setSemanticModel(semanticModelBridge); new CutFreeTextAction(freeTextGraphNode, null); fail( "IllegalArgumentException is expected because semanticModel's typeInfo is not equal " + "to 'FreeText'."); } catch (IllegalArgumentException e) { // success } }
private void addNode(GraphNode graphNode) { if (graphNodeMap == null) { graphNodeMap = new HashMap<String, GraphNode<?>>(); } else { final AttributeNode old = graphNodeMap.get(graphNode.getRegistrationName()); if (old != null) { log.debugf( "Encountered request to add entity graph node [%s] using a name [%s] under which another " + "node is already registered [%s]", old.getClass().getName(), graphNode.getRegistrationName(), graphNode.getClass().getName()); } } graphNodeMap.put(graphNode.getAttributeName(), graphNode); }
public String resolve(GraphNode graph) { StringBuffer retValue = new StringBuffer("empty"); if (graph.getProbe() instanceof IndexedProbe) { retValue.setLength(0); IndexedProbe ip = (IndexedProbe) graph.getProbe(); retValue.append(ip.getIndexName()); // Check to see if a label is defined and needed to add String label = graph.getProbe().getLabel(); if (label != null) { retValue.append(" (" + label + ")"); } } else { logger.debug("Bad graph definition for " + graph); } return retValue.toString(); }
/** * Set up environment. * * @throws Exception exception */ public void setUp() throws Exception { Helper.clearNamespace(); Helper.initNamespace(); freeTextGraphNode = new GraphNode(); freeTextGraphNode.setContainer(new GraphElement() {}); }
public String resolve(GraphNode graph) { String url = ""; Probe<?, ?> probe = graph.getProbe(); if (probe instanceof UrlProbe) { url = ((UrlProbe) probe).getUrlAsString(); } return url; }
/** * BFS algorith * * @param: print boolean if to print node during traversal * @return List of nodes in order visited */ public ArrayList<String> bfs(boolean print) { ArrayList<String> ops = new ArrayList<>(); GraphNode v = source; ArrayList<GraphNode> Q = new ArrayList<>(); Q.add(v); v.setVisited(true); while (Q.size() != 0) { v = Q.remove(0); if (print) System.out.println(v); ops.add(v.toString()); // if(checkStoppingCondition(v, getN())) { // return; // } List<Integer> edgeTarget = matrix.get(v.getID()); for (int i = 0; i < edgeTarget.size(); ++i) { if (edgeTarget.get(i) == 1) { GraphNode w = info.get(i + 1); if (!w.getVisited()) { Q.add(w); w.setVisited(true); } } } } return ops; }
public void bfs(GraphNode n) { Queue<GraphNode> q = new LinkedList<>(); q.add(n); n.visited = true; while (!q.isEmpty()) { GraphNode nd = q.poll(); System.out.print(nd + " "); if (nd.neibhours != null) { for (GraphNode gn : nd.neibhours) { if (!gn.visited) { q.add(gn); gn.visited = true; } } } } }
public void add(T evalFirstValue, T evalAfterValue) { GraphNode<T> firstNode = null; GraphNode<T> afterNode = null; if (nodes.containsKey(evalFirstValue)) { firstNode = nodes.get(evalFirstValue); } else { firstNode = createNode(evalFirstValue); nodes.put(evalFirstValue, firstNode); } if (nodes.containsKey(evalAfterValue)) { afterNode = nodes.get(evalAfterValue); } else { afterNode = createNode(evalAfterValue); nodes.put(evalAfterValue, afterNode); } firstNode.addGoingOutNode(afterNode); afterNode.addComingInNode(firstNode); }
void updateNodeLabel(InternalNodeLayout internalNode) { if (internalNode.isDisposed()) { return; } IFigure figure = internalNode.getNode().getFigure(); GraphLabel label = (GraphLabel) nodeFigureToLabel.get(figure); IFigure fisheye = getFisheyeFigure(figure); if (fisheye != null) { figure = fisheye; } if (label == null) { label = new GraphLabel(false); label.setForegroundColor(ColorConstants.white); label.setBackgroundColor(ColorConstants.red); FontData fontData = Display.getDefault().getSystemFont().getFontData()[0]; fontData.setHeight(6); label.setFont(new Font(Display.getCurrent(), fontData)); figure.addFigureListener(nodeFigureListener); addLabelForFigure(figure, label); nodeFigureToLabel.put(figure, label); } GraphNode graphNode = internalNode.getNode(); if (!graphNode.getGraphModel().canExpand(graphNode) || graphNode.getGraphModel().canCollapse(graphNode) || internalNode.isPruned()) { label.setVisible(false); } else { NodeLayout[] successors = internalNode.getSuccessingNodes(); int numberOfHiddenSuccessors = 0; for (int i = 0; i < successors.length; i++) { if (successors[i].isPruned()) { numberOfHiddenSuccessors++; } } String labelText = numberOfHiddenSuccessors > 0 ? "" + numberOfHiddenSuccessors : ""; if (!labelText.equals(label.getText())) { label.setText(labelText); } label.setVisible(true); } refreshLabelBounds(figure, label); }
public void allPaths(GraphNode n1, GraphNode n2, int index) { if (n1 == null || n2 == null) return; aa[index] = n1; n1.visited = true; index++; if (n1 == n2) { for (int i = 0; i < index; i++) System.out.print(aa[i] + " "); System.out.println(); n1.visited = false; return; } if (n1.neibhours != null) { GraphNode[] nbr = n1.neibhours; for (int i = 0; i < nbr.length; i++) { if (!nbr[i].visited) allPaths(nbr[i], n2, index); } } n1.visited = false; }
private void generateShortestPathsFrom(GraphNode source) throws NegativeEdgeException { Iterator<GraphNode> l = g.getNodeIterator(); ListIterator<GraphEdge> m; FibonacciHeap<GraphNode> h = new FibonacciHeap<GraphNode>(); GraphNode t, v; GraphEdge e; h.insert(source, 0); data(source).setPrev(null); data(source).setIncidentEdge(null); this.source = source; while (l.hasNext()) { t = l.next(); if (t == source) continue; data(t).setPrev(null); data(t).setIncidentEdge(null); h.insert(t, Integer.MAX_VALUE); } while (!h.isEmpty()) { t = h.extractMin(); m = t.getEdgeIterator(); while (m.hasNext()) { e = m.next(); if (g.getNodeById(e.getTarget().getId()) == null) { m.remove(); continue; } if (e.getWeight() < 0) { throw new NegativeEdgeException( "Dijkstra's algorithm won't work on graphs with negative edge weights!"); } v = e.getTarget(); if (h.getKey(v) > h.getKey(t) + e.getWeight()) { try { h.decreaseKey(v, h.getKey(t) + e.getWeight()); } catch (KeyNotLessException x) { // can't happen! } data(v).setPrev(t); data(v).setIncidentEdge(e); } } } }