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 }
/** * Given a set of SCC nodes make this the lead member of the SCC and reroute all incoming and * outgoing links accordingly. This eager rewrite is based on the assumption that there are few * cycles so it is better to rewrite once and keep the graph easy to traverse. */ public void makeLeadNodeFor(Set<GraphNode> members) { // Accumulate all successors Set<GraphNode> newSucc = new HashSet<>(); Set<GraphNode> newSuccClosed = new HashSet<>(); for (GraphNode n : members) { newSucc.addAll(n.succ); newSuccClosed.addAll(n.succClosed); } newSucc.removeAll(members); newSuccClosed.removeAll(members); succ = newSucc; succClosed = newSuccClosed; // Rewrite all direct successors to have us as predecessor for (GraphNode n : succ) { n.pred.removeAll(members); n.pred.add(this); } // Find all predecessor nodes and relink link them to point to us Set<GraphNode> done = new HashSet<>(); Set<GraphNode> newAliases = new HashSet<>(); for (GraphNode member : members) { addSiblings(newAliases, member); } becomeLeaderOf(newAliases); for (GraphNode n : members) { if (n != this) { pred.addAll(n.pred); n.relocateAllRefTo(this, done); n.becomeSubordinateOf(this); } } pred.removeAll(members); }
/** * 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; }
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; } }
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; }
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); } }
/** Dump a set to a string for debug. */ private static String dumpSet(Set<GraphNode> s) { StringBuffer sb = new StringBuffer(); sb.append("{"); boolean started = false; for (GraphNode value : s) { if (started) { sb.append(", "); } else { started = true; } sb.append(value.toString()); } sb.append("}"); return sb.toString(); }
/** * 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 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); }
/** Visit each predecessor of this node applying the given visitor. Breadth first. */ private <Alpha, Beta> void doVisitPredecessors( Visitor<Alpha, Beta> visitor, Alpha arg1, Beta arg2, Set<GraphNode> seen) { if (seen.add(this)) { Collection<GraphNode> allKill = null; for (Iterator<GraphNode> i = pred.iterator(); i.hasNext(); ) { GraphNode pred = i.next(); List<GraphNode> kill = visitor.visit(pred, this, arg1, arg2); if (kill != null) { if (allKill == null) allKill = new ArrayList<GraphNode>(); allKill.addAll(kill); } } if (allKill != null) pred.removeAll(allKill); for (Iterator<GraphNode> i = pred.iterator(); i.hasNext(); ) { GraphNode pred = i.next(); pred.doVisitPredecessors(visitor, arg1, arg2, seen); } } }
/** * @param fname String file name to read info from * @return Map indexed by node id of Node classes */ public Map<Integer, GraphNode> getNodeInfo(String fname) { try { BufferedReader br = new BufferedReader(new FileReader(fname)); String line; boolean firstLine = true; Map<Integer, GraphNode> nodes = new HashMap<>(); while ((line = br.readLine()) != null) { if (firstLine) { firstLine = false; continue; } List<String> words = Arrays.asList(line.split("\\s")); ArrayList<String> realWords = new ArrayList<>(); for (String w : words) { if (w.equals("")) continue; else { realWords.add(w); } } if (realWords.size() != 4) { continue; } GraphNode node = new GraphNode( Integer.parseInt(realWords.get(0)), realWords.get(1), realWords.get(2), realWords.get(3)); nodes.put(node.getID(), node); } br.close(); return nodes; } catch (FileNotFoundException e) { e.printStackTrace(); return null; } catch (IOException e) { e.printStackTrace(); return null; } }
/** * Iterative DFS algorithm * * @return List of nodes in order visited */ public ArrayList<String> dfs_iter(boolean print) { ArrayList<String> ops = new ArrayList<>(); GraphNode v = source; List<GraphNode> stack = new ArrayList<>(); stack.add(v); while (stack.size() != 0) { v = stack.remove(stack.size() - 1); if (v.getVisited() == false) { if (print) System.out.println(v); ops.add(v.toString()); v.setVisited(true); 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); stack.add(w); } } } } return ops; }
@Override GraphNode leadNode(GraphNode unlessSpecified) { return leader.leadNode(); }
public void resetNodes() { for (GraphNode node : info.values()) { node.setVisited(false); } }
/** * Check if we have found our node * * @param v Node we are analyzing * @param n int size of graph * @return True if v is our searched node */ public boolean checkStoppingCondition(GraphNode v, Integer n) { if (n == 6) { if (Integer.parseInt(v.getPopulation()) > 500000 && 150 <= Float.parseFloat(v.getElevation()) && Float.parseFloat(v.getElevation()) <= 200) { return true; } } else if (n == 100) { if (v.getCity().equals("SouthAva") && Integer.parseInt(v.getPopulation()) == 2042542 && Float.parseFloat(v.getElevation()) <= 1074.0) { return true; } } else if (n == 1000) { if (v.getCity().equals("NewMarlene") && Integer.parseInt(v.getPopulation()) == 47182047 && Float.parseFloat(v.getElevation()) >= 8.0) { return true; } } else if (n == 10000) { if (v.getCity().equals("Careyland") && Integer.parseInt(v.getPopulation()) <= 5086547 && Float.parseFloat(v.getElevation()) >= 1645.0) { return true; } } return false; }
private GraphNode<T> createNode(T value) { GraphNode<T> node = new GraphNode<T>(); node.value = value; return node; }