Examples with Edge edu.cmu.tetrad.graph.Edge used on opensource projects

Example 6 with Edge

use of edu.cmu.tetrad.graph.Edge in project tetrad by cmu-phil.

the class FirstInflection method search.

@Override
public Graph search(DataModel dataSet, Parameters parameters) {
    Parameters _parameters = new Parameters(parameters);
    Graph _previous = null;
    int _prevDiff = Integer.MAX_VALUE;
    double _value = 0.0;
    if (increment > 0) {
        for (double value = low - increment; value <= high + 0.0000001; value += increment) {
            double value0 = getValue(value, parameters);
            _parameters.set(parameter, value0);
            intialGraph = algorithm.search(dataSet, _parameters);
            if (_previous == null) {
                _previous = intialGraph;
                continue;
            }
            intialGraph = GraphUtils.replaceNodes(intialGraph, _previous.getNodes());
            Set<Edge> edges1 = intialGraph.getEdges();
            int numEdges = edges1.size();
            Set<Edge> edges2 = _previous.getEdges();
            edges2.removeAll(edges1);
            int diff = edges2.size();
            System.out.println(parameter + " = " + _parameters.getDouble(parameter) + " # edges = " + numEdges + " # additional = " + diff);
            if (diff >= _prevDiff) {
                break;
            }
            _previous = intialGraph;
            _value = _parameters.getDouble(parameter);
            _prevDiff = diff;
        }
        if (_value == Math.round((low + increment) * 1000000000.0) / 1000000000.0) {
            for (double value = low; value >= Double.NEGATIVE_INFINITY; value -= increment) {
                value = getValue(value, parameters);
                _parameters.set(parameter, value);
                intialGraph = algorithm.search(dataSet, _parameters);
                intialGraph = GraphUtils.replaceNodes(intialGraph, _previous.getNodes());
                Set<Edge> edges1 = intialGraph.getEdges();
                int numEdges = edges1.size();
                Set<Edge> edges2 = intialGraph.getEdges();
                edges2.removeAll(_previous.getEdges());
                int diff = edges2.size();
                System.out.println(parameter + " = " + _parameters.getDouble(parameter) + " # edges = " + numEdges + " # additional = " + diff);
                if (diff >= _prevDiff) {
                    break;
                }
                _previous = intialGraph;
                _value = _parameters.getDouble(parameter);
                _prevDiff = diff;
            }
        }
    } else {
        for (double value = high; value >= low - 0.0000001; value += increment) {
            double value0 = getValue(value, parameters);
            _parameters.set(parameter, value0);
            intialGraph = algorithm.search(dataSet, _parameters);
            if (_previous == null) {
                _previous = intialGraph;
                continue;
            }
            intialGraph = GraphUtils.replaceNodes(intialGraph, _previous.getNodes());
            Set<Edge> edges1 = intialGraph.getEdges();
            int numEdges = edges1.size();
            Set<Edge> edges2 = _previous.getEdges();
            edges2.removeAll(edges1);
            int diff = edges2.size();
            System.out.println(parameter + " = " + _parameters.getDouble(parameter) + " # edges = " + numEdges + " # additional = " + diff);
            if (diff >= _prevDiff) {
                break;
            }
            _previous = intialGraph;
            _value = _parameters.getDouble(parameter);
            _prevDiff = diff;
        }
        if (_value == Math.round((high - increment) * 1000000000.0) / 1000000000.0) {
            for (double value = low; value >= Double.NEGATIVE_INFINITY; value -= increment) {
                value = getValue(value, parameters);
                _parameters.set(parameter, value);
                intialGraph = algorithm.search(dataSet, _parameters);
                intialGraph = GraphUtils.replaceNodes(intialGraph, _previous.getNodes());
                Set<Edge> edges1 = intialGraph.getEdges();
                int numEdges = edges1.size();
                Set<Edge> edges2 = intialGraph.getEdges();
                edges2.removeAll(_previous.getEdges());
                int diff = edges2.size();
                System.out.println(parameter + " = " + _parameters.getDouble(parameter) + " # edges = " + numEdges + " # additional = " + diff);
                if (diff >= _prevDiff) {
                    break;
                }
                _previous = intialGraph;
                _value = _parameters.getDouble(parameter);
                _prevDiff = diff;
            }
        }
    }
    System.out.println(parameter + " = " + _value);
    return _previous;
// double tolerance = parameters.getDouble("StARS.tolerance");
// 
// MultivariateOptimizer search = new PowellOptimizer(tolerance, tolerance);
// FittingFunction f = new FittingFunction(_parameters, algorithm, low, high, parameter, (DataSet) dataSet);
// PointValuePair p = search.optimize(
// new InitialGuess(new double[]{increment, increment}),
// new ObjectiveFunction(f),
// GoalType.MINIMIZE,
// new MaxEval(100000)
// );
// 
// 
// double[] point = p.getPoint();
// 
// double p1 = point[0];
// double p2 = point[1];
// 
// p1 = Math.round(p1 * 10.0) / 10.0;
// p2 = Math.round(p2 * 10.0) / 10.0;
// 
// double value = Math.max(p1, p2);
// 
// //        double value = (p.getPoint()[0] + p.getPoint()[1]) / 2;
// System.out.println(parameter + " = " + getValue(value, parameters));
// _parameters.set(parameter, getValue(value, parameters));
// 
// return algorithm.search(dataSet, _parameters);
}

Example 7 with Edge

use of edu.cmu.tetrad.graph.Edge in project tetrad by cmu-phil.

the class WGfci method search.

public Graph search() {
    test.setAlpha(alpha);
    Graph g = gfci.search();
    Graph out = new EdgeListGraph(searchVariables);
    for (int i = 0; i < searchVariables.size(); i++) {
        for (int j = i + 1; j < searchVariables.size(); j++) {
            Node x = searchVariables.get(i);
            Node y = searchVariables.get(j);
            List<Node> xNodes = variablesPerNode.get(x);
            List<Node> yNodes = variablesPerNode.get(y);
            int left = 0;
            int right = 0;
            int total = 0;
            for (int k = 0; k < xNodes.size(); k++) {
                for (int l = 0; l < yNodes.size(); l++) {
                    Edge e = g.getEdge(xNodes.get(k), yNodes.get(l));
                    if (e != null) {
                        total++;
                        if (e.pointsTowards(xNodes.get(k)))
                            left++;
                        if (e.pointsTowards(yNodes.get(l)))
                            right++;
                    }
                }
            }
            if (total > 0) {
                if (left == total)
                    out.addDirectedEdge(y, x);
                else if (right == total)
                    out.addDirectedEdge(x, y);
                else
                    out.addUndirectedEdge(x, y);
            }
        }
    }
    return out;
}

Example 8 with Edge

use of edu.cmu.tetrad.graph.Edge in project tetrad by cmu-phil.

the class SessionEditorNode method finishedEditingDialog.

/**
 * After editing a session node, either run changes or break edges.
 */
private void finishedEditingDialog() {
    if (!ModificationRegistery.modelHasChanged(getSessionNode())) {
        return;
    }
    // dialog.
    for (SessionNode child : getChildren()) {
        if (child.getModel() != null) {
            continue;
        }
        return;
    }
    Object[] options = { "Execute", "Break Edges" };
    Component centeringComp = SessionEditorNode.this;
    int selection = JOptionPane.showOptionDialog(centeringComp, "Changing this node will affect its children.\n" + "Click on \"Execute\" to percolate changes down.\n" + "Click on \"Break Edges\" to leave the children the same.", "Warning", JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE, null, options, options[0]);
    if (selection == 0) {
        for (SessionNode child : getChildren()) {
            executeSessionNode(child, true);
        }
    } else if (selection == 1) {
        for (Edge edge : sessionWrapper.getEdges(getModelNode())) {
            // only break edges to children.
            if (edge.getNode2() == getModelNode()) {
                SessionNodeWrapper otherWrapper = (SessionNodeWrapper) edge.getNode1();
                SessionNode other = otherWrapper.getSessionNode();
                if (getChildren().contains(other)) {
                    sessionWrapper.removeEdge(edge);
                }
            } else {
                SessionNodeWrapper otherWrapper = (SessionNodeWrapper) edge.getNode2();
                SessionNode other = otherWrapper.getSessionNode();
                if (getChildren().contains(other)) {
                    sessionWrapper.removeEdge(edge);
                }
            }
        }
    }
}

Example 9 with Edge

use of edu.cmu.tetrad.graph.Edge in project tetrad by cmu-phil.

the class JsonUtils method parseJSONArrayToTetradEdges.

public static Set<Edge> parseJSONArrayToTetradEdges(Graph graph, JSONArray jArray) {
    Set<Edge> edges = new HashSet<>();
    for (int i = 0; i < jArray.length(); i++) {
        Edge edge = parseJSONObjectToTetradEdge(graph, jArray.getJSONObject(i));
        edges.add(edge);
    }
    return edges;
}

Example 10 with Edge

use of edu.cmu.tetrad.graph.Edge in project tetrad by cmu-phil.

the class Vicinity method findEdges.

// ***********()(*&(*%^#$%^&*^&%^%^%******
// this is like findRange, but it returns the edges within the range in one step, without iterating chunksize
private List<Edge> findEdges(Edge edge, int range) {
    Set<Edge> edges = new HashSet<>();
    NodeEqualityMode.setEqualityMode(NodeEqualityMode.Type.OBJECT);
    // create separate range values for x y and z, scaled by xdist ydist zdist
    int xrange = (int) Math.ceil(range / xDist);
    int yrange = (int) Math.ceil(range / yDist);
    int zrange = (int) Math.ceil(range / zDist);
    // initialize the edge sets
    Set<Edge> node1edges1 = new HashSet<>();
    Set<Edge> node1edges2 = new HashSet<>();
    // list edges with either endpoint near node1
    for (int x = getX(edge.getNode1(), locationMap) - xrange; x <= getX(edge.getNode1(), locationMap) + xrange; x++) {
        for (int y = getY(edge.getNode1(), locationMap) - yrange; y <= getY(edge.getNode1(), locationMap) + yrange; y++) {
            for (int z = getZ(edge.getNode1(), locationMap) - zrange; z <= getZ(edge.getNode1(), locationMap) + zrange; z++) {
                if (x < xLow || x > xHigh || y < yLow || y > yHigh || z < zLow || z > zHigh)
                    continue;
                // if (Coords1.get(new Integer[] {x,y,z}) == null) continue;
                if (Coords1.get(Arrays.asList(x, y, z)) != null)
                    node1edges1.addAll(Coords1.get(Arrays.asList(x, y, z)));
                if (Coords2.get(Arrays.asList(x, y, z)) != null)
                    node1edges2.addAll(Coords2.get(Arrays.asList(x, y, z)));
            }
        }
    }
    int x2 = getX(edge.getNode2(), locationMap);
    int y2 = getY(edge.getNode2(), locationMap);
    int z2 = getZ(edge.getNode2(), locationMap);
    // if one or both of the above lists is nonempty, find edges where the other endpoint is near node2!
    if (!node1edges1.isEmpty()) {
        for (Edge edge11 : node1edges1) {
            int x = getX(edge11.getNode2(), locationMap);
            int y = getY(edge11.getNode2(), locationMap);
            int z = getZ(edge11.getNode2(), locationMap);
            if (x >= x2 - xrange && x <= x2 + xrange && y >= y2 - yrange && y <= y2 + yrange && z >= z2 - zrange && z <= z2 + zrange) {
                edges.add(edge11);
            }
        }
    }
    if (!node1edges2.isEmpty()) {
        for (Edge edge12 : node1edges2) {
            int x = getX(edge12.getNode1(), locationMap);
            int y = getY(edge12.getNode1(), locationMap);
            int z = getZ(edge12.getNode1(), locationMap);
            if (x >= x2 - xrange && x <= x2 + xrange && y >= y2 - yrange && y <= y2 + yrange && z >= z2 - zrange && z <= z2 + zrange) {
                edges.add(edge12);
            }
        }
    }
    return new ArrayList<>(edges);
}