public PathResult bruteSearch(Map map, Node curNode) { PathResult p = new PathResult(); if (curNode.getName().equals("END")) { p.setPath("END"); return p; } PathResult[] depends = new PathResult[curNode.getNumDepend()]; for (int i = 0; i < curNode.getNumDepend(); i++) { Path path = map.getPath(curNode.getName(), curNode.getDepend(i).getName()); depends[i] = (new PathResult(path.getA().getName() + ",", path.getWeight())) .append(bruteSearch(map, curNode.getDepend(i))); // System.out.println(i + " " + depends[i]); } int minIndex = 0; for (int i = 1; i < depends.length; i++) { if (depends[i].getWeight() < depends[minIndex].getWeight()) minIndex = i; } return depends[minIndex]; }
private void calculateArrowsForward(Node x, Node y, Graph graph) { clearArrow(x, y); if (!knowledgeEmpty()) { if (getKnowledge().isForbidden(x.getName(), y.getName())) { return; } } List<Node> naYX = getNaYX(x, y, graph); List<Node> t = getTNeighbors(x, y, graph); DepthChoiceGenerator gen = new DepthChoiceGenerator(t.size(), t.size()); int[] choice; while ((choice = gen.next()) != null) { List<Node> s = GraphUtils.asList(choice, t); if (!knowledgeEmpty()) { if (!validSetByKnowledge(y, s)) { continue; } } double bump = insertEval(x, y, s, naYX, graph); if (bump > 0.0) { Arrow arrow = new Arrow(bump, x, y, s, naYX); sortedArrows.add(arrow); addLookupArrow(x, y, arrow); } } }
public void outputContext(PrintWriter printStream, String indentString) { AppearanceNode appearance = getAppearanceNodes(); if (appearance != null) { if (appearance.isInstanceNode() == false) { String nodeName = appearance.getName(); if (nodeName != null && 0 < nodeName.length()) printStream.println( indentString + "\t" + "appearance DEF " + appearance.getName() + " Appearance {"); else printStream.println(indentString + "\t" + "appearance Appearance {"); appearance.outputContext(printStream, indentString + "\t"); printStream.println(indentString + "\t" + "}"); } else printStream.println(indentString + "\t" + "appearance USE " + appearance.getName()); } Node geonode = getGeometry3DNode(); if (geonode != null) { if (geonode.isInstanceNode() == false) { String nodeName = geonode.getName(); if (nodeName != null && 0 < nodeName.length()) printStream.println( indentString + "\t" + "geometry DEF " + geonode.getName() + " " + geonode.getTypeString() + " {"); else printStream.println(indentString + "\t" + "geometry " + geonode.getTypeString() + " {"); geonode.outputContext(printStream, indentString + "\t"); printStream.println(indentString + "\t" + "}"); } else printStream.println(indentString + "\t" + "geometry USE " + geonode.getName()); } }
public boolean hasNode(String nodeName) { if (start.getName().equals(nodeName) || end.getName().equals(nodeName)) { return true; } else { return false; } }
private Graph condense(Graph mimStructure, Graph mimbuildStructure) { // System.out.println("Uncondensed: " + mimbuildStructure); Map<Node, Node> substitutions = new HashMap<Node, Node>(); for (Node node : mimbuildStructure.getNodes()) { for (Node _node : mimStructure.getNodes()) { if (node.getName().startsWith(_node.getName())) { substitutions.put(node, _node); break; } substitutions.put(node, node); } } HashSet<Node> nodes = new HashSet<Node>(substitutions.values()); Graph graph = new EdgeListGraph(new ArrayList<Node>(nodes)); for (Edge edge : mimbuildStructure.getEdges()) { Node node1 = substitutions.get(edge.getNode1()); Node node2 = substitutions.get(edge.getNode2()); if (node1 == node2) continue; if (graph.isAdjacentTo(node1, node2)) continue; graph.addEdge(new Edge(node1, node2, edge.getEndpoint1(), edge.getEndpoint2())); } // System.out.println("Condensed: " + graph); return graph; }
public TimeLagGraphWrapper(GraphWrapper graphWrapper) { if (graphWrapper == null) { throw new NullPointerException("No graph wrapper."); } TimeLagGraph graph = new TimeLagGraph(); Graph _graph = graphWrapper.getGraph(); for (Node node : _graph.getNodes()) { Node _node = node.like(node.getName() + ":0"); _node.setNodeType(node.getNodeType()); graph.addNode(_node); } for (Edge edge : _graph.getEdges()) { if (!Edges.isDirectedEdge(edge)) { throw new IllegalArgumentException(); } Node from = edge.getNode1(); Node to = edge.getNode2(); Node _from = graph.getNode(from.getName(), 1); Node _to = graph.getNode(to.getName(), 0); graph.addDirectedEdge(_from, _to); } this.graph = graph; }
/** * <<<<<<< HEAD ���ߵ�valueֵ���й��� ======= 按边的value值进行过滤 >>>>>>> seuvislogwws/master * * @param filter * @return */ public SankeyGraph FilterByEdgeValue(double filter) { Set<Integer> nodeset = new HashSet<Integer>(); Iterator<? extends Edge> iterator_links = this.links.iterator(); while (iterator_links.hasNext()) { Edge edge = iterator_links.next(); double value = ((StreamEdge) edge).getValue(); if (value < filter) iterator_links.remove(); // �Ƴ�� else { nodeset.add(edge.getSource()); nodeset.add(edge.getTarget()); } } Iterator<? extends Node> iterator_nodes = this.nodes.iterator(); while (iterator_nodes.hasNext()) { Node node = iterator_nodes.next(); if (!nodeset.contains(node.getName())) { // ����nodes�� iterator_nodes.remove(); } } // System.out.println( "���˺�nodes�Ĵ�С�� "+this.nodes.size()); // �����˹���json����ٴΰ�node��name��0��ʼ�ź� int index = 0; for (Node n : this.nodes) { int old_name = n.getName(); int new_name = index++; n.setName(new_name); for (Edge e : this.links) { if (e.getSource() == old_name) e.setSource(new_name); if (e.getTarget() == old_name) e.setTarget(new_name); } } return this; }
/** * Use background knowledge to decide if an insert or delete operation does not orient edges in a * forbidden direction according to prior knowledge. If some orientation is forbidden in the * subset, the whole subset is forbidden. */ private boolean validSetByKnowledge(Node y, List<Node> subset) { for (Node node : subset) { if (getKnowledge().isForbidden(node.getName(), y.getName())) { return false; } } return true; }
/** * Transforms a maximally directed pattern (PDAG) represented in graph <code>g</code> into an * arbitrary DAG by modifying <code>g</code> itself. Based on the algorithm described in * Chickering (2002) "Optimal structure identification with greedy search" Journal of Machine * Learning Research. R. Silva, June 2004 */ public static void pdagToDag(Graph g) { Graph p = new EdgeListGraph(g); List<Edge> undirectedEdges = new ArrayList<Edge>(); for (Edge edge : g.getEdges()) { if (edge.getEndpoint1() == Endpoint.TAIL && edge.getEndpoint2() == Endpoint.TAIL && !undirectedEdges.contains(edge)) { undirectedEdges.add(edge); } } g.removeEdges(undirectedEdges); List<Node> pNodes = p.getNodes(); do { Node x = null; for (Node pNode : pNodes) { x = pNode; if (p.getChildren(x).size() > 0) { continue; } Set<Node> neighbors = new HashSet<Node>(); for (Edge edge : p.getEdges()) { if (edge.getNode1() == x || edge.getNode2() == x) { if (edge.getEndpoint1() == Endpoint.TAIL && edge.getEndpoint2() == Endpoint.TAIL) { if (edge.getNode1() == x) { neighbors.add(edge.getNode2()); } else { neighbors.add(edge.getNode1()); } } } } if (neighbors.size() > 0) { Collection<Node> parents = p.getParents(x); Set<Node> all = new HashSet<Node>(neighbors); all.addAll(parents); if (!GraphUtils.isClique(all, p)) { continue; } } for (Node neighbor : neighbors) { Node node1 = g.getNode(neighbor.getName()); Node node2 = g.getNode(x.getName()); g.addDirectedEdge(node1, node2); } p.removeNode(x); break; } pNodes.remove(x); } while (pNodes.size() > 0); }
private double pValue(Node node, List<Node> parents) { List<Double> _residuals = new ArrayList<Double>(); Node _target = node; List<Node> _regressors = parents; Node target = getVariable(variables, _target.getName()); List<Node> regressors = new ArrayList<Node>(); for (Node _regressor : _regressors) { Node variable = getVariable(variables, _regressor.getName()); regressors.add(variable); } DATASET: for (int m = 0; m < dataSets.size(); m++) { RegressionResult result = regressions.get(m).regress(target, regressors); TetradVector residualsSingleDataset = result.getResiduals(); for (int h = 0; h < residualsSingleDataset.size(); h++) { if (Double.isNaN(residualsSingleDataset.get(h))) { continue DATASET; } } DoubleArrayList _residualsSingleDataset = new DoubleArrayList(residualsSingleDataset.toArray()); double mean = Descriptive.mean(_residualsSingleDataset); double std = Descriptive.standardDeviation( Descriptive.variance( _residualsSingleDataset.size(), Descriptive.sum(_residualsSingleDataset), Descriptive.sumOfSquares(_residualsSingleDataset))); for (int i2 = 0; i2 < _residualsSingleDataset.size(); i2++) { // _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2) - mean) / // std); if (isMeanCenterResiduals()) { _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2) - mean)); } // _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2))); } for (int k = 0; k < _residualsSingleDataset.size(); k++) { _residuals.add(_residualsSingleDataset.get(k)); } } double[] _f = new double[_residuals.size()]; for (int k = 0; k < _residuals.size(); k++) { _f[k] = _residuals.get(k); } return new AndersonDarlingTest(_f).getP(); }
public Node getOppositeEnd(String nodeName) { assert start.getName().equals(nodeName) || end.getName().equals(nodeName) : "Node must belong to link"; if (start.getName().equals(nodeName)) { return end; } else { return start; } }
public String getGraphCommands() { String commands = ""; for (Node aNode : nodeList) { commands += ("node " + aNode.getName() + "\n"); } for (DirectedArc dirArc : dirArcList) { commands += ("dir-arc " + dirArc.getParent().getName() + " " + dirArc.getChild().getName() + " " + dirArc.getRelation() + "\n"); } for (UndirectedArc undirArc : undirArcList) { Node[] nodes = undirArc.getNodes(); commands += ("undir-arc " + nodes[0].getName() + " " + nodes[1].getName() + " " + undirArc.getRelation() + "\n"); } return commands; }
/** Recursively outputs the contents of the given node. */ private static void dump(Node node) throws RepositoryException { // First output the node path System.out.println(node.getPath()); // Skip the virtual (and large!) jcr:system subtree if (node.getName().equals("jcr:system")) { return; } // Then output the properties PropertyIterator properties = node.getProperties(); while (properties.hasNext()) { Property property = properties.nextProperty(); if (property.getDefinition().isMultiple()) { // A multi-valued property, print all values Value[] values = property.getValues(); for (int i = 0; i < values.length; i++) { System.out.println(property.getPath() + " = " + values[i].getString()); } } else { // A single-valued property System.out.println(property.getPath() + " = " + property.getString()); } } // Finally output all the child nodes recursively NodeIterator nodes = node.getNodes(); while (nodes.hasNext()) { dump(nodes.nextNode()); } }
private ImmutableMap<String, Node<?>> buildNodeMap(List<Node<?>> nodes) { ImmutableMap.Builder<String, Node<?>> builder = ImmutableMap.builder(); for (Node<?> node : nodes) { builder.put(node.getName(), node); } return builder.build(); }
public void deliverMessages() { while (!getSequencer().getSequenceNbsOfMachine().isEmpty()) { Node node = new Node(getLastMinimumSequenceNumber(getSequencer().getSequenceNbsOfMachine())); node.buildListDependencies(node.getName(), this); node.resolveDependencies(this); } }
private List<String> getNames(List<Node> nodes) { List<String> names = new ArrayList<String>(); for (Node node : nodes) { names.add(node.getName()); } return names; }
public boolean isViolatedBy(Graph graph) { for (Edge edge : graph.getEdges()) { if (!edge.isDirected()) { continue; } Node from = Edges.getDirectedEdgeTail(edge); Node to = Edges.getDirectedEdgeHead(edge); if (isForbidden(from.getName(), to.getName())) { return true; } } return false; }
private Graph changeLatentNames(Graph full, Clusters measurements, List<String> latentVarList) { Graph g2 = null; try { g2 = (Graph) new MarshalledObject(full).get(); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } for (int i = 0; i < measurements.getNumClusters(); i++) { List<String> d = measurements.getCluster(i); String latentName = latentVarList.get(i); for (Node node : full.getNodes()) { if (!(node.getNodeType() == NodeType.LATENT)) { continue; } List<Node> _children = full.getChildren(node); _children.removeAll(ReidentifyVariables.getLatents(full)); List<String> childNames = getNames(_children); if (new HashSet<String>(childNames).equals(new HashSet<String>(d))) { g2.getNode(node.getName()).setName(latentName); } } } return g2; }
public NodeId getNodeId(Node node) { String _name = node.getName(); String[] tokens = _name.split(":"); if (tokens.length > 2) throw new IllegalArgumentException("Name may contain only one colon: " + _name); if (tokens[0].length() == 0) throw new IllegalArgumentException( "Part to the left of the colon may " + "not be empty; that's the name of the variable: " + _name); String name = tokens[0]; int lag; if (tokens.length == 1) { lag = 0; } else { lag = Integer.parseInt(tokens[1]); if (lag == 0) throw new IllegalArgumentException("Lag 0 edges don't have :0 descriptors"); } if (lag < 0) throw new IllegalArgumentException("Lag is less than 0: " + lag); if (lag > getMaxLag()) throw new IllegalArgumentException("Lag is greater than the maximum lag: " + lag); return new NodeId(name, lag); }
/** * Gets a node with the specified name * * @param name name of graph node which is to be retrieved * @throws Exception node is not found * @return graph Node */ public Node getNode(String name) throws Exception { for (Node aNode : nodeList) { if (aNode.getName().equals(name)) { return aNode; } } throw new Exception(String.format("Node %s not found", name)); }
/** Returns the string in nodelist which matches string in BK. */ public static Node translate(String a, List<Node> nodes) { for (Node node : nodes) { if ((node.getName()).equals(a)) { return node; } } return null; }
private Node getVariable(List<Node> variables, String name) { for (Node node : variables) { if (name.equals(node.getName())) { return node; } } return null; }
/** * Helper method. Appears to check if an arrowpoint is permitted by background knowledge. * * @param x The possible other node. * @param y The possible point node. * @return Whether the arrowpoint is allowed. */ private boolean isArrowpointAllowed(Node x, Node y) { if (graph.getEndpoint(x, y) == Endpoint.ARROW) { return true; } if (graph.getEndpoint(x, y) == Endpoint.TAIL) { return false; } if (graph.getEndpoint(y, x) == Endpoint.ARROW) { if (!knowledge.isForbidden(x.getName(), y.getName())) return true; } if (graph.getEndpoint(y, x) == Endpoint.TAIL) { if (!knowledge.isForbidden(x.getName(), y.getName())) return true; } return graph.getEndpoint(y, x) == Endpoint.CIRCLE; }
public String toString() { StringBuffer buffer = new StringBuffer(); buffer.append("DataNode: " + getName() + "\n"); if (getComments() != null) { for (Node commentNode : getComments()) { buffer.append("\t comment: " + commentNode.getName() + "\n"); } } return buffer.toString(); }
private String reportIfDiscrete(Graph dag, DataSet dataSet) { List vars = dataSet.getVariables(); Map<String, DiscreteVariable> nodesToVars = new HashMap<String, DiscreteVariable>(); for (int i = 0; i < dataSet.getNumColumns(); i++) { DiscreteVariable var = (DiscreteVariable) vars.get(i); String name = var.getName(); Node node = new GraphNode(name); nodesToVars.put(node.getName(), var); } BayesPm bayesPm = new BayesPm(new Dag(dag)); List<Node> nodes = bayesPm.getDag().getNodes(); for (Node node : nodes) { Node var = nodesToVars.get(node.getName()); if (var instanceof DiscreteVariable) { DiscreteVariable var2 = nodesToVars.get(node.getName()); int numCategories = var2.getNumCategories(); List<String> categories = new ArrayList<String>(); for (int j = 0; j < numCategories; j++) { categories.add(var2.getCategory(j)); } bayesPm.setCategories(node, categories); } } BayesProperties properties = new BayesProperties(dataSet, dag); properties.setGraph(dag); NumberFormat nf = NumberFormat.getInstance(); nf.setMaximumFractionDigits(4); StringBuilder buf = new StringBuilder(); buf.append("\nP-value = ").append(properties.getLikelihoodRatioP()); buf.append("\nDf = ").append(properties.getPValueDf()); buf.append("\nChi square = ").append(nf.format(properties.getPValueChisq())); buf.append("\nBIC score = ").append(nf.format(properties.getBic())); buf.append("\n\nH0: Completely disconnected graph."); return buf.toString(); }
// Thanks for Giordano Sassaroli <*****@*****.**> (09/08/03) private Property getProperty(Node varNode) { Property prop = new Property(); if (varNode == null) return prop; // remove the event namespace String variableName = varNode.getName(); int index = variableName.lastIndexOf(':'); if (index != -1) variableName = variableName.substring(index + 1); prop.setName(variableName); prop.setValue(varNode.getValue()); return prop; }
public Node getNode(String name) { if (name == null) return null; int nLists = size(); for (int n = 0; n < nLists; n++) { Node node = getNode(n); String nodeName = node.getName(); if (name.compareTo(nodeName) == 0) return node; } return null; }
@Test public void testFullReplaceMissingProperty() throws Exception { try { Node target = (Node) createValue("name", "%{garbage}").getTarget(); assertEquals("bar", target.getName()); fail("Expected IllegalStateException"); } catch (BeanCreationException e) { String message = e.getMessage(); assertTrue("Wrong message: " + message, message.toLowerCase().contains("cannot bind")); } }
@Override public String toString() { return com.google.common.base.Objects.toStringHelper(this) .add("name", name) .add("nodeType", nodeType) .add("parent", (parent != null ? parent.getName() : null)) .add("namespace", namespace) .add("comment", comment) .add("children", children) .toString(); }
// Invalid if then nodes or graph changes. private void calculateArrowsBackward(Node x, Node y, Graph graph) { if (x == y) { return; } if (!graph.isAdjacentTo(x, y)) { return; } if (!knowledgeEmpty()) { if (!getKnowledge().noEdgeRequired(x.getName(), y.getName())) { return; } } List<Node> naYX = getNaYX(x, y, graph); clearArrow(x, y); List<Node> _naYX = new ArrayList<Node>(naYX); DepthChoiceGenerator gen = new DepthChoiceGenerator(_naYX.size(), _naYX.size()); int[] choice; while ((choice = gen.next()) != null) { List<Node> H = GraphUtils.asList(choice, _naYX); if (!knowledgeEmpty()) { if (!validSetByKnowledge(y, H)) { continue; } } double bump = deleteEval(x, y, H, naYX, graph); if (bump > 0.0) { Arrow arrow = new Arrow(bump, x, y, H, naYX); sortedArrows.add(arrow); addLookupArrow(x, y, arrow); } } }