* In addition, the PC Stable modification to PC has been included (Colombo and Maathuis).
*
* @author Joseph Ramsey.
*/
public class PcStable implements GraphSearch {
/**
* The independence test used for the PC search.
*/
private IndependenceTest independenceTest;
/**
* Forbidden and required edges for the search.
*/
private IKnowledge knowledge = new Knowledge();
/**
* Sepset information accumulated in the search.
*/
private SepsetMap sepsets;
/**
* The maximum number of nodes conditioned on in the search. The default it 1000.
*/
private int depth = 1000;
/**
* The graph that's constructed during the search.
*/
private Graph graph;
/**
* Elapsed time of the most recent search.
*/
private long elapsedTime;
/**
* True if cycles are to be aggressively prevented. May be expensive for large graphs (but also useful for large
* graphs).
*/
private boolean aggressivelyPreventCycles = false;
/**
* The logger for this class. The config needs to be set.
*/
private TetradLogger logger = TetradLogger.getInstance();
/**
* The initial graph for the Fast Adjacency Search, or null if there is none.
*/
private Graph initialGraph = null;
/**
* Prints independencies info to out.
*/
private boolean verbose = false;
private PrintStream out = System.out;
//=============================CONSTRUCTORS==========================//
/**
* Constructs a new PC search using the given independence test as oracle.
*
* @param independenceTest The oracle for conditional independence facts. This does not make a copy of the
* independence test, for fear of duplicating the data set!
*/
public PcStable(IndependenceTest independenceTest) {
if (independenceTest == null) {
throw new NullPointerException();
}
this.independenceTest = independenceTest;
}
//==============================PUBLIC METHODS========================//
/**
* @return true iff edges will not be added if they would create cycles.
*/
public boolean isAggressivelyPreventCycles() {
return this.aggressivelyPreventCycles;
}
/**
* @param aggressivelyPreventCycles Set to true just in case edges will not be addeds if they would create cycles.
*/
public void setAggressivelyPreventCycles(boolean aggressivelyPreventCycles) {
this.aggressivelyPreventCycles = aggressivelyPreventCycles;
}
/**
* @return the independence test being used in the search.
*/
public IndependenceTest getIndependenceTest() {
return independenceTest;
}
/**
* @return the knowledge specification used in the search. Non-null.
*/
public IKnowledge getKnowledge() {
return knowledge;
}
/**
* Sets the knowledge specification to be used in the search. May not be null.
*/
public void setKnowledge(IKnowledge knowledge) {
if (knowledge == null) {
throw new NullPointerException();
}
this.knowledge = knowledge;
}
/**
* @return the sepset map from the most recent search. Non-null after the first call to search().
*/
public SepsetMap getSepsets() {
return this.sepsets;
}
/**
* @return the current depth of search--that is, the maximum number of conditioning nodes for any conditional
* independence checked.
*/
public int getDepth() {
return depth;
}
/**
* Sets the depth of the search--that is, the maximum number of conditioning nodes for any conditional independence
* checked.
*
* @param depth The depth of the search. The default is 1000. A value of -1 may be used to indicate that the depth
* should be high (1000). A value of Integer.MAX_VALUE may not be used, due to a bug on multi-core
* machines.
*/
public void setDepth(int depth) {
if (depth < -1) {
throw new IllegalArgumentException("Depth must be -1 or >= 0: " + depth);
}
if (depth > 1000) {
throw new IllegalArgumentException("Depth must be <= 1000.");
}
this.depth = depth;
}
/**
* Runs PC starting with a complete graph over all nodes of the given conditional independence test, using the given
* independence test and knowledge and returns the resultant graph. The returned graph will be a pattern if the
* independence information is consistent with the hypothesis that there are no latent common causes. It may,
* however, contain cycles or bidirected edges if this assumption is not born out, either due to the actual presence
* of latent common causes, or due to statistical errors in conditional independence judgments.
*/
public Graph search() {
return search(independenceTest.getVariables());
}
/**
* Runs PC starting with a commplete graph over the given list of nodes, using the given independence test and
* knowledge and returns the resultant graph. The returned graph will be a pattern if the independence information
* is consistent with the hypothesis that there are no latent common causes. It may, however, contain cycles or
* bidirected edges if this assumption is not born out, either due to the actual presence of latent common causes,
* or due to statistical errors in conditional independence judgments.
*
* All of the given nodes must be in the domain of the given conditional independence test.
*/
public Graph search(List