/**
* Constructs a test using a given data set. If a data set is provided (that is, a tabular data
* set), fourth moment statistics can be calculated (p. 160); otherwise, it must be assumed that
* the data are multivariate Gaussian.
*/
public DeltaSextadTest(DataSet dataSet) {
if (dataSet == null) {
throw new NullPointerException();
}
if (!dataSet.isContinuous()) {
throw new IllegalArgumentException();
}
this.cov = new CovarianceMatrix(dataSet);
List<DataSet> data1 = new ArrayList<DataSet>();
data1.add(dataSet);
List<DataSet> data2 = DataUtils.center(data1);
this.dataSet = data2.get(0);
this.data = this.dataSet.getDoubleData().transpose().toArray();
this.N = dataSet.getNumRows();
this.variables = dataSet.getVariables();
this.numVars = dataSet.getNumColumns();
this.variablesHash = new HashMap<Node, Integer>();
for (int i = 0; i < variables.size(); i++) {
variablesHash.put(variables.get(i), i);
}
this.means = new double[numVars];
for (int i = 0; i < numVars; i++) {
means[i] = mean(data[i], N);
}
}
/** Find the dataModel model. (If it's a list, take the one that's selected.) */
private DataModel getSelectedDataModel(DataWrapper dataWrapper) {
DataModelList dataModelList = dataWrapper.getDataModelList();
if (dataModelList.size() > 1) {
return dataModelList;
}
DataModel dataModel = dataWrapper.getSelectedDataModel();
if (dataModel instanceof DataSet) {
DataSet dataSet = (DataSet) dataModel;
if (dataSet.isDiscrete()) {
return dataSet;
} else if (dataSet.isContinuous()) {
return dataSet;
} else if (dataSet.isMixed()) {
return dataSet;
}
throw new IllegalArgumentException(
"<html>"
+ "This data set contains a mixture of discrete and continuous "
+ "<br>columns; there are no algorithm in Tetrad currently to "
+ "<br>search over such data sets."
+ "</html>");
} else if (dataModel instanceof ICovarianceMatrix) {
return dataModel;
} else if (dataModel instanceof TimeSeriesData) {
return dataModel;
}
throw new IllegalArgumentException("Unexpected dataModel source: " + dataModel);
}
/**
* Executes the algorithm, producing (at least) a result workbench. Must be implemented in the
* extending class.
*/
public void execute() {
DataModel source = getDataModel();
if (!(source instanceof DataSet)) {
throw new IllegalArgumentException("Expecting a rectangular data set.");
}
DataSet data = (DataSet) source;
if (!data.isContinuous()) {
throw new IllegalArgumentException("Expecting a continuous data set.");
}
// Lingam_old lingam = new Lingam_old();
// lingam.setPruningDone(true);
// lingam.setAlpha(getParams().getIndTestParams().getAlpha());
// GraphWithParameters result = lingam.lingam(data);
// Graph graph = result.getGraph();
Lingam lingam = new Lingam();
LingamParams params = (LingamParams) getParams();
lingam.setPruneFactor(params.getPruneFactor());
Graph graph = lingam.search(data);
setResultGraph(graph);
if (getSourceGraph() != null) {
GraphUtils.arrangeBySourceGraph(graph, getSourceGraph());
} else {
GraphUtils.circleLayout(graph, 200, 200, 150);
}
}
public FindOneFactorClustersWithCausalIndicators(
DataSet dataSet, TestType testType, double alpha) {
if (dataSet.isContinuous()) {
this.variables = dataSet.getVariables();
this.test = new ContinuousTetradTest(dataSet, testType, alpha);
this.indTest = new IndTestFisherZ(dataSet, alpha);
this.alpha = alpha;
this.testType = testType;
this.dataModel = dataSet;
if (testType == TestType.TETRAD_DELTA) {
deltaTest = new DeltaTetradTest(dataSet);
deltaTest.setCacheFourthMoments(false);
}
this.cov = new CovarianceMatrix(dataSet);
} else if (dataSet.isDiscrete()) {
this.variables = dataSet.getVariables();
this.test = new DiscreteTetradTest(dataSet, alpha);
this.indTest = new IndTestChiSquare(dataSet, alpha);
this.alpha = alpha;
this.testType = testType;
this.dataModel = dataSet;
if (testType == TestType.TETRAD_DELTA) {
deltaTest = new DeltaTetradTest(dataSet);
deltaTest.setCacheFourthMoments(false);
}
}
}
private void calcStats() {
// Graph resultGraph = getAlgorithmRunner().getResultGraph();
IGesRunner runner = (IGesRunner) getAlgorithmRunner();
if (runner.getTopGraphs().isEmpty()) {
throw new IllegalArgumentException(
"No patterns were recorded. Please adjust the number of " + "patterns to store.");
}
Graph resultGraph = runner.getTopGraphs().get(runner.getIndex()).getGraph();
if (getAlgorithmRunner().getDataModel() instanceof DataSet) {
// resultGraph may be the output of a PC search.
// Such graphs sometimes contain doubly directed edges.
// /We converte such edges to directed edges here.
// For the time being an orientation is arbitrarily selected.
Set<Edge> allEdges = resultGraph.getEdges();
for (Edge edge : allEdges) {
if (edge.getEndpoint1() == Endpoint.ARROW && edge.getEndpoint2() == Endpoint.ARROW) {
// Option 1 orient it from node1 to node2
resultGraph.setEndpoint(edge.getNode1(), edge.getNode2(), Endpoint.ARROW);
// Option 2 remove such edges:
resultGraph.removeEdge(edge);
}
}
Pattern pattern = new Pattern(resultGraph);
PatternToDag ptd = new PatternToDag(pattern);
Graph dag = ptd.patternToDagMeekRules();
DataSet dataSet = (DataSet) getAlgorithmRunner().getDataModel();
String report;
if (dataSet.isContinuous()) {
report = reportIfContinuous(dag, dataSet);
} else if (dataSet.isDiscrete()) {
report = reportIfDiscrete(dag, dataSet);
} else {
throw new IllegalArgumentException("");
}
JScrollPane dagWorkbenchScroll = dagWorkbenchScroll(dag);
modelStatsText.setLineWrap(true);
modelStatsText.setWrapStyleWord(true);
modelStatsText.setText(report);
removeStatsTabs();
tabbedPane.addTab("DAG in pattern", dagWorkbenchScroll);
tabbedPane.addTab("DAG Model Statistics", modelStatsText);
}
}
/**
* Constructs a new Independence test which checks independence facts based on the correlation
* matrix implied by the given data set (must be continuous). The given significance level is
* used.
*
* @param dataSet A data set containing only continuous columns.
* @param alpha The alpha level of the test.
*/
public IndTestFisherZShortTriangular(DataSet dataSet, double alpha) {
if (!(dataSet.isContinuous())) {
throw new IllegalArgumentException("Data set must be continuous.");
}
this.covMatrix = new ShortTriangularMatrix(dataSet.getNumColumns());
this.covMatrix.becomeCorrelationMatrix(dataSet);
this.variables = dataSet.getVariables();
setAlpha(alpha);
this.deterministicTest = new IndTestFisherZGeneralizedInverse(dataSet, alpha);
this.dataSet = dataSet;
}
/**
* Executes the algorithm, producing (at least) a result workbench. Must be implemented in the
* extending class.
*/
public void execute() {
DataModel source = getDataModel();
if (!(source instanceof DataSet)) {
throw new IllegalArgumentException("Expecting a rectangular data set.");
}
DataSet data = (DataSet) source;
if (!data.isContinuous()) {
throw new IllegalArgumentException("Expecting a continuous data set.");
}
Lingam lingam = new Lingam();
lingam.setAlpha(getParams().getIndTestParams().getAlpha());
lingam.setPruningDone(true);
lingam.setAlpha(getParams().getIndTestParams().getAlpha());
GraphWithParameters result = lingam.lingam(data);
setResultGraph(result.getGraph());
GraphUtils.arrangeBySourceGraph(getResultGraph(), getSourceGraph());
}
