/**
* @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;
}
////////////////////////////////////////////////
// collect in rTupleList all unshielded tuples
////////////////////////////////////////////////
private List<Node[]> getRTuples() {
List<Node[]> rTuples = new ArrayList<Node[]>();
List<Node> nodes = graph.getNodes();
for (Node j : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(j);
if (adjacentNodes.size() < 2) {
continue;
}
ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
int[] combination;
while ((combination = cg.next()) != null) {
Node i = adjacentNodes.get(combination[0]);
Node k = adjacentNodes.get(combination[1]);
// Skip triples that are shielded.
if (!graph.isAdjacentTo(i, k)) {
Node[] newTuple = {i, j, k};
rTuples.add(newTuple);
}
}
}
return (rTuples);
}
public List<Triple> getUnshieldedCollidersFromGraph(Graph graph) {
List<Triple> colliders = new ArrayList<>();
List<Node> nodes = graph.getNodes();
for (Node b : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(b);
if (adjacentNodes.size() < 2) {
continue;
}
ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
int[] combination;
while ((combination = cg.next()) != null) {
Node a = adjacentNodes.get(combination[0]);
Node c = adjacentNodes.get(combination[1]);
// Skip triples that are shielded.
if (graph.isAdjacentTo(a, c)) {
continue;
}
if (graph.isDefCollider(a, b, c)) {
colliders.add(new Triple(a, b, c));
}
}
}
return colliders;
}
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);
}
}
}
/**
* Step C of PC; orients colliders using specified sepset. That is, orients x *-* y *-* z as x *->
* y <-* z just in case y is in Sepset({x, z}).
*/
public Map<Triple, Double> findCollidersUsingSepsets(
SepsetProducer sepsetProducer, Graph graph, boolean verbose, IKnowledge knowledge) {
TetradLogger.getInstance().log("details", "Starting Collider Orientation:");
Map<Triple, Double> colliders = new HashMap<>();
System.out.println("Looking for colliders");
List<Node> nodes = graph.getNodes();
for (Node b : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(b);
if (adjacentNodes.size() < 2) {
continue;
}
ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
int[] combination;
while ((combination = cg.next()) != null) {
Node a = adjacentNodes.get(combination[0]);
Node c = adjacentNodes.get(combination[1]);
// Skip triples that are shielded.
if (graph.isAdjacentTo(a, c)) {
continue;
}
List<Node> sepset = sepsetProducer.getSepset(a, c);
if (sepset == null) continue;
// if (sepsetProducer.getPValue() < 0.5) continue;
if (!sepset.contains(b)) {
if (verbose) {
// boolean dsep = this.dsep.isIndependent(a, c);
// System.out.println("QQQ p = " + independenceTest.getPValue() +
// " " + dsep);
System.out.println(
"\nCollider orientation <" + a + ", " + b + ", " + c + "> sepset = " + sepset);
}
colliders.put(new Triple(a, b, c), sepsetProducer.getPValue());
TetradLogger.getInstance()
.log("colliderOrientations", SearchLogUtils.colliderOrientedMsg(a, b, c, sepset));
}
}
}
TetradLogger.getInstance().log("details", "Finishing Collider Orientation.");
System.out.println("Done finding colliders");
return colliders;
}
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 static boolean meekR1Locally2(
Graph graph, Knowledge knowledge, IndependenceTest test, int depth) {
List<Node> nodes = graph.getNodes();
boolean changed = true;
while (changed) {
changed = false;
for (Node a : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(a);
if (adjacentNodes.size() < 2) {
continue;
}
ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
int[] combination;
while ((combination = cg.next()) != null) {
Node b = adjacentNodes.get(combination[0]);
Node c = adjacentNodes.get(combination[1]);
// Skip triples that are shielded.
if (graph.isAdjacentTo(b, c)) {
continue;
}
if (graph.getEndpoint(b, a) == Endpoint.ARROW && graph.isUndirectedFromTo(a, c)) {
if (existsLocalSepsetWithoutDet(b, a, c, test, graph, depth)) {
continue;
}
if (isArrowpointAllowed(a, c, knowledge)) {
graph.setEndpoint(a, c, Endpoint.ARROW);
TetradLogger.getInstance()
.edgeOriented(SearchLogUtils.edgeOrientedMsg("Meek R1", graph.getEdge(a, c)));
changed = true;
}
} else if (graph.getEndpoint(c, a) == Endpoint.ARROW && graph.isUndirectedFromTo(a, b)) {
if (existsLocalSepsetWithoutDet(b, a, c, test, graph, depth)) {
continue;
}
if (isArrowpointAllowed(a, b, knowledge)) {
graph.setEndpoint(a, b, Endpoint.ARROW);
TetradLogger.getInstance()
.edgeOriented(SearchLogUtils.edgeOrientedMsg("Meek R1", graph.getEdge(a, b)));
changed = true;
}
}
}
}
}
return changed;
}
/**
* Performs step C of the algorithm, as indicated on page xxx of CPS, with the modification that
* X--W--Y is oriented as X-->W<--Y if W is *determined by* the sepset of (X, Y), rather than W
* just being *in* the sepset of (X, Y).
*/
public static void pcdOrientC(
SepsetMap set, IndependenceTest test, Knowledge knowledge, Graph graph) {
TetradLogger.getInstance().log("info", "Staring Collider Orientation:");
List<Node> nodes = graph.getNodes();
for (Node y : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(y);
if (adjacentNodes.size() < 2) {
continue;
}
ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
int[] combination;
while ((combination = cg.next()) != null) {
Node x = adjacentNodes.get(combination[0]);
Node z = adjacentNodes.get(combination[1]);
// Skip triples that are shielded.
if (graph.isAdjacentTo(x, z)) {
continue;
}
List<Node> sepset = set.get(x, z);
if (sepset == null) {
continue;
}
List<Node> augmentedSet = new LinkedList<Node>(sepset);
augmentedSet.add(y);
if (test.determines(sepset, y)) {
continue;
}
//
if (!test.splitDetermines(sepset, x, z) && test.splitDetermines(augmentedSet, x, z)) {
continue;
}
if (!isArrowpointAllowed(x, y, knowledge) || !isArrowpointAllowed(z, y, knowledge)) {
continue;
}
graph.setEndpoint(x, y, Endpoint.ARROW);
graph.setEndpoint(z, y, Endpoint.ARROW);
TetradLogger.getInstance()
.log("colliderOriented", SearchLogUtils.colliderOrientedMsg(x, y, z));
}
}
TetradLogger.getInstance().log("info", "Finishing Collider Orientation.");
}
/** Meek's rule R3. If a--b, a--c, a--d, c-->b, c-->b, then orient a-->b. */
public static boolean meekR3(Graph graph, Knowledge knowledge) {
List<Node> nodes = graph.getNodes();
boolean changed = false;
for (Node a : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(a);
if (adjacentNodes.size() < 3) {
continue;
}
for (Node b : adjacentNodes) {
List<Node> otherAdjacents = new LinkedList<Node>(adjacentNodes);
otherAdjacents.remove(b);
if (!graph.isUndirectedFromTo(a, b)) {
continue;
}
ChoiceGenerator cg = new ChoiceGenerator(otherAdjacents.size(), 2);
int[] combination;
while ((combination = cg.next()) != null) {
Node c = otherAdjacents.get(combination[0]);
Node d = otherAdjacents.get(combination[1]);
if (graph.isAdjacentTo(c, d)) {
continue;
}
if (!graph.isUndirectedFromTo(a, c)) {
continue;
}
if (!graph.isUndirectedFromTo(a, d)) {
continue;
}
if (graph.isDirectedFromTo(c, b) && graph.isDirectedFromTo(d, b)) {
if (isArrowpointAllowed(a, b, knowledge)) {
graph.setEndpoint(a, b, Endpoint.ARROW);
TetradLogger.getInstance()
.edgeOriented(SearchLogUtils.edgeOrientedMsg("Meek R3", graph.getEdge(a, b)));
changed = true;
break;
}
}
}
}
}
return changed;
}
/** Returns true iif the given set forms a clique in the given graph. */
private static boolean isClique(List<Node> nodes, Graph graph) {
for (int i = 0; i < nodes.size() - 1; i++) {
for (int j = i + 1; j < nodes.size(); j++) {
if (!graph.isAdjacentTo(nodes.get(i), nodes.get(j))) {
return false;
}
}
}
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 static double characteristicPathLength(Graph g) {
List<Node> nodes = g.getNodes();
int total = 0;
int count = 0;
for (int i = 0; i < nodes.size(); i++) {
for (int j = i; j < nodes.size(); j++) {
int shortest = shortestPath(nodes.get(i), nodes.get(j), g);
total += shortest;
count++;
}
}
return total / (double) count;
}
/**
* Sets the expression which should be evaluated when calculating new values for the given
* parameter. These values are used to initialize the freeParameters.
*
* @param parameter The parameter whose initial value needs to be computed.
* @param expressionString The formula for picking initial values.
* @throws ParseException If the formula cannot be parsed or contains variable names.
*/
public void setParameterEstimationInitializationExpression(
String startsWith, String parameter, String expressionString) throws ParseException {
if (parameter == null) {
throw new NullPointerException("Parameter was null.");
}
if (startsWith == null) {
throw new NullPointerException("StartsWith expression was null.");
}
if (startsWith.contains(" ")) {
throw new IllegalArgumentException("StartsWith expression contains spaces.");
}
if (expressionString == null) {
throw new NullPointerException("Expression string was null.");
}
// Parse the expression. This could throw an ParseException, but that exception needs to handed
// up the
// chain, because the interface will need it.
ExpressionParser parser = new ExpressionParser();
Expression expression = parser.parseExpression(expressionString);
List<String> parameterNames = parser.getParameters();
if (parameterNames.size() > 0) {
throw new IllegalArgumentException(
"Initial distribution may not " + "contain parameters: " + expressionString);
}
parameterEstimationInitializationExpressions.put(parameter, expression);
parameterEstimationInitializationExpressionStrings.put(parameter, expressionString);
startsWithParametersTemplates.put(startsWith, expressionString);
}
// Quartets first , then triples.
private Set<Set<Integer>> estimateClustersSAG() {
Map<Node, Set<Node>> adjacencies;
if (depth == -2) {
adjacencies = new HashMap<Node, Set<Node>>();
for (Node node : variables) {
HashSet<Node> _nodes = new HashSet<Node>(variables);
_nodes.remove(node);
adjacencies.put(node, _nodes);
}
} else {
System.out.println("Running PC adjacency search...");
Graph graph = new EdgeListGraph(variables);
Fas fas = new Fas(graph, indTest);
fas.setDepth(depth); // 1?
adjacencies = fas.searchMapOnly();
System.out.println("...done.");
}
List<Integer> _variables = new ArrayList<Integer>();
for (int i = 0; i < variables.size(); i++) _variables.add(i);
Set<Set<Integer>> pureClusters = findPureClusters(_variables, adjacencies);
for (Set<Integer> cluster : pureClusters) _variables.removeAll(cluster);
Set<Set<Integer>> mixedClusters =
findMixedClusters(_variables, unionPure(pureClusters), adjacencies);
Set<Set<Integer>> allClusters = new HashSet<Set<Integer>>(pureClusters);
allClusters.addAll(mixedClusters);
return allClusters;
}
private String clusterSizes(List<List<Node>> partition, List<List<Node>> trueClusters) {
String s = "";
FOR:
for (int i = 0; i < partition.size(); i++) {
List<Node> cluster = partition.get(i);
s += cluster.size();
for (List<Node> trueCluster : trueClusters) {
if (trueCluster.containsAll(cluster)) {
// Collections.sort(trueCluster);
// Collections.sort(cluster);
// System.out.println(trueCluster + " " + cluster);
s += "p";
if (i < partition.size() - 1) {
s += ",";
}
continue FOR;
}
}
if (i < partition.size() - 1) {
s += ",";
}
}
return s;
}
/**
* 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 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;
}
private int numClustered(List<List<Node>> partition) {
int sum = 0;
for (int i = 0; i < partition.size(); i++) {
List<Node> cluster = partition.get(i);
sum += cluster.size();
}
return sum;
}
public static boolean existsLocalSepsetWithoutDet(
Node x, Node y, Node z, IndependenceTest test, Graph graph, int depth) {
Set<Node> __nodes = new HashSet<Node>(graph.getAdjacentNodes(x));
__nodes.addAll(graph.getAdjacentNodes(z));
__nodes.remove(x);
__nodes.remove(z);
List<Node> _nodes = new LinkedList<Node>(__nodes);
TetradLogger.getInstance()
.log("adjacencies", "Adjacents for " + x + "--" + y + "--" + z + " = " + _nodes);
int _depth = depth;
if (_depth == -1) {
_depth = 1000;
}
_depth = Math.min(_depth, _nodes.size());
for (int d = 0; d <= _depth; d++) {
if (_nodes.size() >= d) {
ChoiceGenerator cg2 = new ChoiceGenerator(_nodes.size(), d);
int[] choice;
while ((choice = cg2.next()) != null) {
List<Node> condSet = asList(choice, _nodes);
if (condSet.contains(y)) {
continue;
}
if (test.determines(condSet, y)) {
continue;
}
// LogUtils.getInstance().finest("Trying " + condSet);
if (test.isIndependent(x, z, condSet)) {
return true;
}
}
}
}
return false;
}
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;
}
}
/** Tests to see if d separation facts are symmetric. */
public void testDSeparation2() {
EdgeListGraphSingleConnections graph =
new EdgeListGraphSingleConnections(
new Dag(GraphUtils.randomGraph(7, 0, 14, 30, 15, 15, true)));
List<Node> nodes = graph.getNodes();
int depth = -1;
for (int i = 0; i < nodes.size(); i++) {
for (int j = i; j < nodes.size(); j++) {
Node x = nodes.get(i);
Node y = nodes.get(j);
List<Node> theRest = new ArrayList<Node>(nodes);
// theRest.remove(x);
// theRest.remove(y);
DepthChoiceGenerator gen = new DepthChoiceGenerator(theRest.size(), depth);
int[] choice;
while ((choice = gen.next()) != null) {
List<Node> z = new LinkedList<Node>();
for (int k = 0; k < choice.length; k++) {
z.add(theRest.get(choice[k]));
}
boolean dConnectedTo = graph.isDConnectedTo(x, y, z);
boolean dConnectedTo1 = graph.isDConnectedTo(y, x, z);
if (dConnectedTo != dConnectedTo1) {
System.out.println(x + " d connected to " + y + " given " + z);
System.out.println(graph);
System.out.println("dconnectedto = " + dConnectedTo);
System.out.println("dconnecteto1 = " + dConnectedTo1);
fail();
}
}
}
}
}
/**
* Step C of PC; orients colliders using specified sepset. That is, orients x *-* y *-* z as x *->
* y <-* z just in case y is in Sepset({x, z}).
*/
public static void orientCollidersUsingSepsets(SepsetMap set, Knowledge knowledge, Graph graph) {
TetradLogger.getInstance().log("info", "Starting Collider Orientation:");
// verifySepsetIntegrity(set, graph);
List<Node> nodes = graph.getNodes();
for (Node a : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(a);
if (adjacentNodes.size() < 2) {
continue;
}
ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
int[] combination;
while ((combination = cg.next()) != null) {
Node b = adjacentNodes.get(combination[0]);
Node c = adjacentNodes.get(combination[1]);
// Skip triples that are shielded.
if (graph.isAdjacentTo(b, c)) {
continue;
}
List<Node> sepset = set.get(b, c);
if (sepset != null
&& !sepset.contains(a)
&& isArrowpointAllowed(b, a, knowledge)
&& isArrowpointAllowed(c, a, knowledge)) {
graph.setEndpoint(b, a, Endpoint.ARROW);
graph.setEndpoint(c, a, Endpoint.ARROW);
TetradLogger.getInstance()
.log("colliderOriented", SearchLogUtils.colliderOrientedMsg(b, a, c, sepset));
}
}
}
TetradLogger.getInstance().log("info", "Finishing Collider Orientation.");
}
// 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);
}
}
}
private double getP(List<Integer> o) {
if (o.size() == 3) return 0;
double max = Double.NEGATIVE_INFINITY;
for (int i = 0; i < 1; i++) {
double c = getP(new ArrayList<Integer>(o), 3);
if (c > max) max = c;
}
return max;
}
/** If */
public static boolean meekR2(Graph graph, Knowledge knowledge) {
List<Node> nodes = graph.getNodes();
boolean changed = false;
for (Node a : nodes) {
List<Node> adjacentNodes = graph.getAdjacentNodes(a);
if (adjacentNodes.size() < 2) {
continue;
}
ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
int[] combination;
while ((combination = cg.next()) != null) {
Node b = adjacentNodes.get(combination[0]);
Node c = adjacentNodes.get(combination[1]);
if (graph.isDirectedFromTo(b, a)
&& graph.isDirectedFromTo(a, c)
&& graph.isUndirectedFromTo(b, c)) {
if (isArrowpointAllowed(b, c, knowledge)) {
graph.setEndpoint(b, c, Endpoint.ARROW);
TetradLogger.getInstance()
.edgeOriented(SearchLogUtils.edgeOrientedMsg("Meek R2", graph.getEdge(b, c)));
}
} else if (graph.isDirectedFromTo(c, a)
&& graph.isDirectedFromTo(a, b)
&& graph.isUndirectedFromTo(c, b)) {
if (isArrowpointAllowed(c, b, knowledge)) {
graph.setEndpoint(c, b, Endpoint.ARROW);
TetradLogger.getInstance()
.edgeOriented(SearchLogUtils.edgeOrientedMsg("Meek R2", graph.getEdge(c, b)));
}
}
}
}
return changed;
}
public static void orientCollidersLocally(
Knowledge knowledge, Graph graph, IndependenceTest test, int depth, Set<Node> nodesToVisit) {
TetradLogger.getInstance().log("info", "Starting Collider Orientation:");
if (nodesToVisit == null) {
nodesToVisit = new HashSet<Node>(graph.getNodes());
}
for (Node a : nodesToVisit) {
List<Node> adjacentNodes = graph.getAdjacentNodes(a);
if (adjacentNodes.size() < 2) {
continue;
}
ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
int[] combination;
while ((combination = cg.next()) != null) {
Node b = adjacentNodes.get(combination[0]);
Node c = adjacentNodes.get(combination[1]);
// Skip triples that are shielded.
if (graph.isAdjacentTo(b, c)) {
continue;
}
if (isArrowpointAllowed1(b, a, knowledge) && isArrowpointAllowed1(c, a, knowledge)) {
if (!existsLocalSepsetWith(b, a, c, test, graph, depth)) {
graph.setEndpoint(b, a, Endpoint.ARROW);
graph.setEndpoint(c, a, Endpoint.ARROW);
TetradLogger.getInstance()
.log("colliderOriented", SearchLogUtils.colliderOrientedMsg(b, a, c));
}
}
}
}
TetradLogger.getInstance().log("info", "Finishing Collider Orientation.");
}
/** Tests to see if d separation facts are symmetric. */
public void testDSeparation() {
EdgeListGraphSingleConnections graph =
new EdgeListGraphSingleConnections(
new Dag(GraphUtils.randomGraph(7, 0, 7, 30, 15, 15, true)));
System.out.println(graph);
List<Node> nodes = graph.getNodes();
int depth = -1;
for (int i = 0; i < nodes.size(); i++) {
for (int j = i + 1; j < nodes.size(); j++) {
Node x = nodes.get(i);
Node y = nodes.get(j);
List<Node> theRest = new ArrayList<Node>(nodes);
theRest.remove(x);
theRest.remove(y);
DepthChoiceGenerator gen = new DepthChoiceGenerator(theRest.size(), depth);
int[] choice;
while ((choice = gen.next()) != null) {
List<Node> z = new LinkedList<Node>();
for (int k = 0; k < choice.length; k++) {
z.add(theRest.get(choice[k]));
}
if (graph.isDSeparatedFrom(x, y, z) != graph.isDSeparatedFrom(y, x, z)) {
fail(
SearchLogUtils.independenceFact(x, y, z)
+ " should have same d-sep result as "
+ SearchLogUtils.independenceFact(y, x, z));
}
}
}
}
}
/**
* @return The edge coefficient matrix of the model, a la SemIm. Note that this will normally need
* to be transposed, since [a][b] is the edge coefficient for a-->b, not b-->a. Sorry.
* History. THESE ARE PARAMETERS OF THE MODEL--THE ONLY PARAMETERS.
*/
public TetradMatrix edgeCoef() {
List<Node> variableNodes = getVariableNodes();
TetradMatrix edgeCoef = new TetradMatrix(variableNodes.size(), variableNodes.size());
for (Edge edge : edgeParameters.keySet()) {
if (Edges.isBidirectedEdge(edge)) {
continue;
}
Node a = edge.getNode1();
Node b = edge.getNode2();
int aindex = variableNodes.indexOf(a);
int bindex = variableNodes.indexOf(b);
double coef = edgeParameters.get(edge);
edgeCoef.set(aindex, bindex, coef);
}
return edgeCoef;
}
public static void arrangeByKnowledgeTiers(Graph graph, Knowledge knowledge) {
if (knowledge.getNumTiers() == 0) {
throw new IllegalArgumentException("There are no Tiers to arrange.");
}
List<Node> nodes = graph.getNodes();
List<String> varNames = new ArrayList<String>();
int ySpace = 500 / knowledge.getNumTiers();
ySpace = ySpace < 50 ? 50 : ySpace;
for (Node node1 : nodes) {
varNames.add(node1.getName());
}
List<String> notInTier = knowledge.getVarsNotInTier(varNames);
int x = 0;
int y = 50 - ySpace;
if (notInTier.size() > 0) {
y += ySpace;
for (String name : notInTier) {
x += 90;
Node node = graph.getNode(name);
if (node != null) {
node.setCenterX(x);
node.setCenterY(y);
}
}
}
for (int i = 0; i < knowledge.getNumTiers(); i++) {
List<String> tier = knowledge.getTier(i);
y += ySpace;
x = -25;
for (String name : tier) {
x += 90;
Node node = graph.getNode(name);
if (node != null) {
node.setCenterX(x);
node.setCenterY(y);
}
}
}
}
public static List<Set<Node>> powerSet(List<Node> nodes) {
List<Set<Node>> subsets = new ArrayList<Set<Node>>();
int total = (int) Math.pow(2, nodes.size());
for (int i = 0; i < total; i++) {
Set<Node> newSet = new HashSet<Node>();
String selection = Integer.toBinaryString(i);
for (int j = selection.length() - 1; j >= 0; j--) {
if (selection.charAt(j) == '1') {
newSet.add(nodes.get(selection.length() - j - 1));
}
}
subsets.add(newSet);
}
return subsets;
}
