public boolean removeEdge(Edge edge) { if (!Edges.isDirectedEdge(edge)) throw new IllegalArgumentException("Only directed edges are expected in the model."); Node node1 = Edges.getDirectedEdgeTail(edge); Node node2 = Edges.getDirectedEdgeHead(edge); NodeId id1 = getNodeId(node1); NodeId id2 = getNodeId(node2); int lag = id1.getLag() - id2.getLag(); boolean removed = false; for (int _lag = 0; _lag <= getMaxLag(); _lag++) { Node from = getNode(id1.getName(), _lag + lag); Node to = getNode(id2.getName(), _lag); if (from != null && to != null) { Edge _edge = getGraph().getEdge(from, to); if (_edge != null) { boolean b = getGraph().removeEdge(_edge); removed = removed || b; } } } return removed; }
private void thenHasEdges(String... expectedEdges) { assertEquals(expectedEdges.length, edges.getCount()); for (int i = 0; i < expectedEdges.length; i++) { Edge actualEdge = edges.getEdge(i); Edge expectedEdge = parseEdge(expectedEdges[i]); assertEquals(actualEdge, expectedEdge); } }
private int getDistance(Vertex node, Vertex target) { for (Edges edge : edges) { if (edge.getStart().equals(node) && edge.getDestination().equals(target)) { return edge.getWeight(); } } throw new RuntimeException("Error"); }
public boolean containsParameter(Edge edge) { if (Edges.isBidirectedEdge(edge)) { edge = Edges.bidirectedEdge( semGraph.getExogenous(edge.getNode1()), semGraph.getExogenous(edge.getNode2())); } return edgeParameters.keySet().contains(edge); }
public void setParameterValue(Edge edge, double value) { if (Edges.isDirectedEdge(edge)) { setEdgeCoefficient(edge.getNode1(), edge.getNode2(), value); } else if (Edges.isBidirectedEdge(edge)) { setErrorCovariance(edge.getNode1(), edge.getNode2(), value); } else { throw new IllegalArgumentException( "Only directed and bidirected edges are supported: " + edge); } }
private List<Vertex> getNeighbors(Vertex node) { List<Vertex> neighbors = new ArrayList<Vertex>(); for (Edges edge : edges) { if (edge.getStart().equals(node) && !isSettled(edge.getDestination())) { neighbors.add(edge.getDestination()); } } return neighbors; }
/** * @return Returns the error covariance matrix of the model. i.e. [a][b] is the covariance of E_a * and E_b, with [a][a] of course being the variance of E_a. THESE ARE NOT PARAMETERS OF THE * MODEL; THEY ARE CALCULATED. Note that elements of this matrix may be Double.NaN; this * indicates that these elements cannot be calculated. */ private TetradMatrix errCovar(Map<Node, Double> errorVariances) { List<Node> variableNodes = getVariableNodes(); List<Node> errorNodes = new ArrayList<Node>(); for (Node node : variableNodes) { errorNodes.add(semGraph.getExogenous(node)); } TetradMatrix errorCovar = new TetradMatrix(errorVariances.size(), errorVariances.size()); for (int index = 0; index < errorNodes.size(); index++) { Node error = errorNodes.get(index); double variance = getErrorVariance(error); errorCovar.set(index, index, variance); } for (int index1 = 0; index1 < errorNodes.size(); index1++) { for (int index2 = 0; index2 < errorNodes.size(); index2++) { Node error1 = errorNodes.get(index1); Node error2 = errorNodes.get(index2); Edge edge = semGraph.getEdge(error1, error2); if (edge != null && Edges.isBidirectedEdge(edge)) { double covariance = getErrorCovariance(error1, error2); errorCovar.set(index1, index2, covariance); } } } return errorCovar; }
/** * Sets the covariance for the a<->b edge to the given covariance, if within range. Otherwise does * nothing. * * @param a a <-> b * @param b a <-> b * @param covar The covariance of a <-> b. * @return true if the coefficent was set (i.e. was within range), false if not. */ public boolean setErrorCovariance(Node a, Node b, final double covar) { Edge edge = Edges.bidirectedEdge(semGraph.getExogenous(a), semGraph.getExogenous(b)); if (edgeParameters.get(edge) == null) { throw new IllegalArgumentException("Not a covariance parameter in this model: " + edge); } if (editingEdge == null || !edge.equals(editingEdge)) { range = getParameterRange(edge); editingEdge = edge; } if (covar > range.getLow() && covar < range.getHigh()) { edgeParameters.put(edge, covar); return true; } else { return false; } // if (!paramInBounds(edge, coef)) { // edgeParameters.put(edge, d); // return false; // } // // edgeParameters.put(edge, coef); // return true; // if (!paramInBounds(edge, covar)) { // edgeParameters.put(edge, d); // return false; // } // // edgeParameters.put(edge, covar); // return true; }
/** * Sets the coefficient for the a->b edge to the given coefficient, if within range. Otherwise * does nothing. * * @param a a -> b * @param b a -> b * @param coef The coefficient of a -> b. * @return true if the coefficent was set (i.e. was within range), false if not. */ public boolean setEdgeCoefficient(Node a, Node b, final double coef) { Edge edge = Edges.directedEdge(a, b); if (edgeParameters.get(edge) == null) { throw new NullPointerException("Not a coefficient parameter in this model: " + edge); } if (editingEdge == null || !edge.equals(editingEdge)) { range = getParameterRange(edge); editingEdge = edge; } if (coef > range.getLow() && coef < range.getHigh()) { edgeParameters.put(edge, coef); return true; } return false; // if (!paramInBounds(edge, coef)) { // edgeParameters.put(edge, d); // return false; // } // // edgeParameters.put(edge, coef); // return true; }
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; }
public static Graph erdosRenyiGraph(int n, int e) { List<Node> nodes = new ArrayList<Node>(); for (int i = 0; i < n; i++) nodes.add(new GraphNode("X" + i)); Graph graph = new EdgeListGraph(nodes); for (int e0 = 0; e0 < e; e0++) { int i1 = RandomUtil.getInstance().nextInt(n); int i2 = RandomUtil.getInstance().nextInt(n); if (i1 == i2) { e0--; continue; } Edge edge = Edges.undirectedEdge(nodes.get(i1), nodes.get(i2)); if (graph.containsEdge(edge)) { e0--; continue; } graph.addEdge(edge); } return graph; }
private boolean existsUnblockedSemiDirectedPath(Node from, Node to, List<Node> cond, Graph G) { Queue<Node> Q = new LinkedList<Node>(); Set<Node> V = new HashSet<Node>(); Q.offer(from); V.add(from); while (!Q.isEmpty()) { Node t = Q.remove(); if (t == to) return true; for (Node u : G.getAdjacentNodes(t)) { Edge edge = G.getEdge(t, u); Node c = Edges.traverseSemiDirected(t, edge); if (c == null) continue; if (cond.contains(c)) continue; if (c == to) return true; if (!V.contains(c)) { V.add(c); Q.offer(c); } } } return false; }
private void addEdge(String a, String b) { try { edges.add(createEdge(a, b)); } catch (Throwable t) { this.t = t; } }
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 boolean isUndirected(Graph graph, Node x, Node y) { List<Edge> edges = graph.getEdges(x, y); if (edges.size() == 1) { Edge edge = graph.getEdge(x, y); return Edges.isUndirectedEdge(edge); } return false; }
/** * @param a a->b * @param b a->b * @return The coefficient for a->b. */ public double getErrorCovariance(Node a, Node b) { Edge edge = Edges.bidirectedEdge(semGraph.getExogenous(a), semGraph.getExogenous(b)); Double d = edgeParameters.get(edge); if (d == null) { throw new IllegalArgumentException("Not a covariance parameter in this model: " + edge); } return d; }
public boolean setMaxLag(int maxLag) { if (maxLag < 0) { throw new IllegalArgumentException("Max lag must be at least 0: " + maxLag); } List<Node> lag0Nodes = getLag0Nodes(); boolean changed = false; if (maxLag > this.getMaxLag()) { this.maxLag = maxLag; for (Node node : lag0Nodes) { addNode(node); } for (Node node : lag0Nodes) { List<Edge> edges = getGraph().getEdges(node); for (Edge edge : edges) { boolean b = addEdge(edge); changed = changed || b; } } } else if (maxLag < this.getMaxLag()) { for (Node node : lag0Nodes) { List<Edge> edges = getGraph().getEdges(node); for (Edge edge : edges) { Node tail = Edges.getDirectedEdgeTail(edge); if (getNodeId(tail).getLag() > maxLag) { getGraph().removeEdge(edge); // throw new IllegalArgumentException("This edge has lag greater // than the new maxLag: " + edge + // " Please remove first."); } } } for (Node _node : getNodes()) { if (getNodeId(_node).getLag() > maxLag) { boolean b = getGraph().removeNode(_node); changed = changed || b; } } this.maxLag = maxLag; } getPcs().firePropertyChange("editingFinished", null, null); return changed; }
/** * @param a a->b * @param b a->b * @return The coefficient for a->b. */ public double getEdgeCoefficient(Node a, Node b) { Edge edge = Edges.directedEdge(a, b); Double d = edgeParameters.get(edge); if (d == null) { return Double.NaN; // throw new IllegalArgumentException("Not a directed edge in this model: " + // edge); } return d; }
private Graph pickDag(Graph graph) { SearchGraphUtils.basicPattern(graph, false); addRequiredEdges(graph); boolean containsUndirected; do { containsUndirected = false; for (Edge edge : graph.getEdges()) { if (Edges.isUndirectedEdge(edge)) { containsUndirected = true; graph.removeEdge(edge); Edge _edge = Edges.directedEdge(edge.getNode1(), edge.getNode2()); graph.addEdge(_edge); } } meekOrient(graph, getKnowledge()); } while (containsUndirected); return graph; }
public boolean addEdge(Edge edge) { if (!Edges.isDirectedEdge(edge)) { throw new IllegalArgumentException("Only directed edges supported: " + edge); } if (!lag0Nodes.contains(edge.getNode2())) { throw new IllegalArgumentException("Edges into the current time lag only: " + edge); } Node node1 = Edges.getDirectedEdgeTail(edge); Node node2 = Edges.getDirectedEdgeHead(edge); NodeId id1 = getNodeId(node1); NodeId id2 = getNodeId(node2); int lag = id1.getLag() - id2.getLag(); if (lag < 0) { throw new IllegalArgumentException("Backward edges not permitted: " + edge); } for (int _lag = getNodeId(node2).getLag() % getNumInitialLags(); _lag <= getMaxLag() - lag; _lag += getNumInitialLags()) { Node from = getNode(id1.getName(), _lag + lag); Node to = getNode(id2.getName(), _lag); if (from == null || to == null) { continue; } Edge _edge = Edges.directedEdge(from, to); if (!getGraph().containsEdge(_edge)) { getGraph().addDirectedEdge(from, to); } } return true; }
private void ruleR1(Graph skeleton, Graph graph, List<Node> nodes) { for (Node node : nodes) { SortedMap<Double, String> scoreReports = new TreeMap<Double, String>(); List<Node> adj = skeleton.getAdjacentNodes(node); DepthChoiceGenerator gen = new DepthChoiceGenerator(adj.size(), adj.size()); int[] choice; double maxScore = Double.NEGATIVE_INFINITY; List<Node> parents = null; while ((choice = gen.next()) != null) { List<Node> _parents = GraphUtils.asList(choice, adj); double score = score(node, _parents); scoreReports.put(-score, _parents.toString()); if (score > maxScore) { maxScore = score; parents = _parents; } } for (double score : scoreReports.keySet()) { TetradLogger.getInstance() .log( "score", "For " + node + " parents = " + scoreReports.get(score) + " score = " + -score); } TetradLogger.getInstance().log("score", ""); if (parents == null) { continue; } if (normal(node, parents)) continue; for (Node _node : adj) { if (parents.contains(_node)) { Edge parentEdge = Edges.directedEdge(_node, node); if (!graph.containsEdge(parentEdge)) { graph.addEdge(parentEdge); } } } } }
private void uncorrelationExogenousVariables() { Graph graph = getWorkbench().getGraph(); Set<Edge> edges = graph.getEdges(); for (Edge edge : edges) { if (Edges.isBidirectedEdge(edge)) { try { graph.removeEdge(edge); } catch (Exception e) { // Ignore. } } } }
/** @return a string representation of the coefficients and variances of the model. */ public String toString() { StringBuilder buf = new StringBuilder(); NumberFormat nf = NumberFormatUtil.getInstance().getNumberFormat(); buf.append("\nStandardized SEM:"); buf.append("\n\nEdge coefficients (parameters):\n"); for (Edge edge : edgeParameters.keySet()) { if (!Edges.isDirectedEdge(edge)) { continue; } buf.append("\n" + edge + " " + nf.format(edgeParameters.get(edge))); } buf.append("\n\nError covariances (parameters):\n"); for (Edge edge : edgeParameters.keySet()) { if (!Edges.isBidirectedEdge(edge)) { continue; } buf.append("\n" + edge + " " + nf.format(edgeParameters.get(edge))); } buf.append("\n\nError variances (calculated):\n"); for (Node error : getErrorNodes()) { double variance = getErrorVariance(error); buf.append("\n" + error + " " + (Double.isNaN(variance) ? "Undefined" : nf.format(variance))); } buf.append("\n"); return buf.toString(); }
public static Graph weightedRandomGraph(int n, int e) { List<Node> nodes = new ArrayList<Node>(); for (int i = 0; i < n; i++) nodes.add(new GraphNode("X" + i)); Graph graph = new EdgeListGraph(nodes); for (int e0 = 0; e0 < e; e0++) { int i1 = weightedRandom(nodes, graph); // int i2 = RandomUtil.getInstance().nextInt(n); int i2 = weightedRandom(nodes, graph); if (!(shortestPath(nodes.get(i1), nodes.get(i2), graph) < 9)) { e0--; continue; } if (i1 == i2) { e0--; continue; } Edge edge = Edges.undirectedEdge(nodes.get(i1), nodes.get(i2)); if (graph.containsEdge(edge)) { e0--; continue; } graph.addEdge(edge); } for (Edge edge : graph.getEdges()) { Node n1 = edge.getNode1(); Node n2 = edge.getNode2(); if (!graph.isAncestorOf(n2, n1)) { graph.removeEdge(edge); graph.addDirectedEdge(n1, n2); } else { graph.removeEdge(edge); graph.addDirectedEdge(n2, n1); } } return graph; }
public boolean setNumInitialLags(int numInitialLags) { if (numInitialLags < 1) { throw new IllegalArgumentException( "The number of initial lags must be at least 1: " + numInitialLags); } if (numInitialLags == this.numInitialLags) return false; List<Node> lag0Nodes = getLag0Nodes(); boolean changed = false; for (Node node : lag0Nodes) { NodeId id = getNodeId(node); for (int lag = 1; lag <= getMaxLag(); lag++) { Node _node = getNode(id.getName(), lag); List<Node> nodesInto = getGraph().getNodesInTo(_node, Endpoint.ARROW); for (Node _node2 : nodesInto) { Edge edge = Edges.directedEdge(_node2, _node); boolean b = getGraph().removeEdge(edge); changed = changed || b; } } } this.numInitialLags = numInitialLags; for (Node node : lag0Nodes) { for (int lag = 0; lag < numInitialLags; lag++) { List<Edge> edges = getGraph().getEdges(node); for (Edge edge : edges) { boolean b = addEdge(edge); changed = changed || b; } } } getPcs().firePropertyChange("editingFinished", null, null); return changed; }
public boolean removeHighLagEdges(int maxLag) { List<Node> lag0Nodes = getLag0Nodes(); boolean changed = false; for (Node node : lag0Nodes) { List<Edge> edges = getGraph().getEdges(node); for (Edge edge : new ArrayList<Edge>(edges)) { Node tail = Edges.getDirectedEdgeTail(edge); if (getNodeId(tail).getLag() > maxLag) { boolean b = getGraph().removeEdge(edge); changed = changed || b; } } } return changed; }
/** * Find all nodes that are connected to Y by an undirected edge that are adjacent to X (that is, * by undirected or directed edge). */ private static List<Node> getNaYX(Node x, Node y, Graph graph) { List<Edge> yEdges = graph.getEdges(y); List<Node> nayx = new ArrayList<Node>(); for (Edge edge : yEdges) { if (!Edges.isUndirectedEdge(edge)) { continue; } Node z = edge.getDistalNode(y); if (!graph.isAdjacentTo(z, x)) { continue; } nayx.add(z); } return nayx; }
/** Get all nodes that are connected to Y by an undirected edge and not adjacent to X. */ private static List<Node> getTNeighbors(Node x, Node y, Graph graph) { List<Edge> yEdges = graph.getEdges(y); List<Node> tNeighbors = new ArrayList<Node>(); for (Edge edge : yEdges) { if (!Edges.isUndirectedEdge(edge)) { continue; } Node z = edge.getDistalNode(y); if (graph.isAdjacentTo(z, x)) { continue; } tNeighbors.add(z); } return tNeighbors; }
private void correlateExogenousVariables() { Graph graph = getWorkbench().getGraph(); if (graph instanceof Dag) { JOptionPane.showMessageDialog( JOptionUtils.centeringComp(), "Cannot add bidirected edges to DAG's."); return; } List<Node> nodes = graph.getNodes(); List<Node> exoNodes = new LinkedList<Node>(); for (int i = 0; i < nodes.size(); i++) { Node node = nodes.get(i); if (graph.isExogenous(node)) { exoNodes.add(node); } } for (int i = 0; i < exoNodes.size(); i++) { loop: for (int j = i + 1; j < exoNodes.size(); j++) { Node node1 = exoNodes.get(i); Node node2 = exoNodes.get(j); List<Edge> edges = graph.getEdges(node1, node2); for (int k = 0; k < edges.size(); k++) { Edge edge = edges.get(k); if (Edges.isBidirectedEdge(edge)) { continue loop; } } graph.addBidirectedEdge(node1, node2); } } }
private void initializeArrowsBackward(Graph graph) { sortedArrows.clear(); lookupArrows.clear(); for (Edge edge : graph.getEdges()) { Node x = edge.getNode1(); Node y = edge.getNode2(); if (!knowledgeEmpty()) { if (!getKnowledge().noEdgeRequired(x.getName(), y.getName())) { continue; } } if (Edges.isDirectedEdge(edge)) { calculateArrowsBackward(x, y, graph); } else { calculateArrowsBackward(x, y, graph); calculateArrowsBackward(y, x, graph); } } }