@Test
public void test2() {
RandomUtil.getInstance().setSeed(2999983L);
int sampleSize = 1000;
List<Node> variableNodes = new ArrayList<>();
ContinuousVariable x1 = new ContinuousVariable("X1");
ContinuousVariable x2 = new ContinuousVariable("X2");
ContinuousVariable x3 = new ContinuousVariable("X3");
ContinuousVariable x4 = new ContinuousVariable("X4");
ContinuousVariable x5 = new ContinuousVariable("X5");
variableNodes.add(x1);
variableNodes.add(x2);
variableNodes.add(x3);
variableNodes.add(x4);
variableNodes.add(x5);
Graph _graph = new EdgeListGraph(variableNodes);
SemGraph graph = new SemGraph(_graph);
graph.addDirectedEdge(x1, x3);
graph.addDirectedEdge(x2, x3);
graph.addDirectedEdge(x3, x4);
graph.addDirectedEdge(x2, x4);
graph.addDirectedEdge(x4, x5);
graph.addDirectedEdge(x2, x5);
SemPm semPm = new SemPm(graph);
SemIm semIm = new SemIm(semPm);
DataSet dataSet = semIm.simulateData(sampleSize, false);
print(semPm);
GeneralizedSemPm _semPm = new GeneralizedSemPm(semPm);
GeneralizedSemIm _semIm = new GeneralizedSemIm(_semPm, semIm);
DataSet _dataSet = _semIm.simulateDataMinimizeSurface(sampleSize, false);
print(_semPm);
// System.out.println(_dataSet);
for (int j = 0; j < dataSet.getNumColumns(); j++) {
double[] col = dataSet.getDoubleData().getColumn(j).toArray();
double[] _col = _dataSet.getDoubleData().getColumn(j).toArray();
double mean = StatUtils.mean(col);
double _mean = StatUtils.mean(_col);
double variance = StatUtils.variance(col);
double _variance = StatUtils.variance(_col);
assertEquals(mean, _mean, 0.3);
assertEquals(1.0, variance / _variance, .2);
}
}
public IndTestFisherZPercentIndependent(List<DataSet> dataSets, double alpha) {
this.dataSets = dataSets;
this.variables = dataSets.get(0).getVariables();
data = new ArrayList<TetradMatrix>();
for (DataSet dataSet : dataSets) {
dataSet = DataUtils.center(dataSet);
TetradMatrix _data = dataSet.getDoubleData();
data.add(_data);
}
ncov = new ArrayList<TetradMatrix>();
for (TetradMatrix d : this.data) ncov.add(d.transpose().times(d).scalarMult(1.0 / d.rows()));
setAlpha(alpha);
rows = new int[dataSets.get(0).getNumRows()];
for (int i = 0; i < getRows().length; i++) getRows()[i] = i;
variablesMap = new HashMap<Node, Integer>();
for (int i = 0; i < variables.size(); i++) {
variablesMap.put(variables.get(i), i);
}
this.recursivePartialCorrelation = new ArrayList<RecursivePartialCorrelation>();
for (TetradMatrix covMatrix : ncov) {
recursivePartialCorrelation.add(new RecursivePartialCorrelation(getVariables(), covMatrix));
}
}
@Test
public void test3() {
RandomUtil.getInstance().setSeed(49293843L);
List<Node> variableNodes = new ArrayList<>();
ContinuousVariable x1 = new ContinuousVariable("X1");
ContinuousVariable x2 = new ContinuousVariable("X2");
ContinuousVariable x3 = new ContinuousVariable("X3");
ContinuousVariable x4 = new ContinuousVariable("X4");
ContinuousVariable x5 = new ContinuousVariable("X5");
variableNodes.add(x1);
variableNodes.add(x2);
variableNodes.add(x3);
variableNodes.add(x4);
variableNodes.add(x5);
Graph _graph = new EdgeListGraph(variableNodes);
SemGraph graph = new SemGraph(_graph);
graph.setShowErrorTerms(true);
Node e1 = graph.getExogenous(x1);
Node e2 = graph.getExogenous(x2);
Node e3 = graph.getExogenous(x3);
Node e4 = graph.getExogenous(x4);
Node e5 = graph.getExogenous(x5);
graph.addDirectedEdge(x1, x3);
graph.addDirectedEdge(x1, x2);
graph.addDirectedEdge(x2, x3);
graph.addDirectedEdge(x3, x4);
graph.addDirectedEdge(x2, x4);
graph.addDirectedEdge(x4, x5);
graph.addDirectedEdge(x2, x5);
graph.addDirectedEdge(x5, x1);
GeneralizedSemPm pm = new GeneralizedSemPm(graph);
List<Node> variablesNodes = pm.getVariableNodes();
print(variablesNodes);
List<Node> errorNodes = pm.getErrorNodes();
print(errorNodes);
try {
pm.setNodeExpression(x1, "cos(b1) + a1 * X5 + E_X1");
pm.setNodeExpression(x2, "a2 * X1 + E_X2");
pm.setNodeExpression(x3, "tan(a3*X2 + a4*X1) + E_X3");
pm.setNodeExpression(x4, "0.1 * E^X2 + X3 + E_X4");
pm.setNodeExpression(x5, "0.1 * E^X4 + a6* X2 + E_X5");
pm.setNodeExpression(e1, "U(0, 1)");
pm.setNodeExpression(e2, "U(0, 1)");
pm.setNodeExpression(e3, "U(0, 1)");
pm.setNodeExpression(e4, "U(0, 1)");
pm.setNodeExpression(e5, "U(0, 1)");
GeneralizedSemIm im = new GeneralizedSemIm(pm);
print(im);
DataSet dataSet = im.simulateDataNSteps(1000, false);
// System.out.println(dataSet);
double[] d1 = dataSet.getDoubleData().getColumn(0).toArray();
double[] d2 = dataSet.getDoubleData().getColumn(1).toArray();
double cov = StatUtils.covariance(d1, d2);
assertEquals(-0.002, cov, 0.001);
} catch (ParseException e) {
e.printStackTrace();
}
}
/**
* Constructs a new standardized SEM IM from the freeParameters in the given SEM IM.
*
* @param im Stop asking me for these things! The given SEM IM!!!
* @param initialization CALCULATE_FROM_SEM if the initial values will be calculated from the
* given SEM IM; INITIALIZE_FROM_DATA if data will be simulated from the given SEM,
* standardized, and estimated.
*/
public StandardizedSemIm(SemIm im, Initialization initialization) {
this.semPm = new SemPm(im.getSemPm());
this.semGraph = new SemGraph(semPm.getGraph());
semGraph.setShowErrorTerms(true);
if (semGraph.existsDirectedCycle()) {
throw new IllegalArgumentException("The cyclic case is not handled.");
}
if (initialization == Initialization.CALCULATE_FROM_SEM) {
// This code calculates the new coefficients directly from the old ones.
edgeParameters = new HashMap<Edge, Double>();
List<Node> nodes = im.getVariableNodes();
TetradMatrix impliedCovar = im.getImplCovar(true);
for (Parameter parameter : im.getSemPm().getParameters()) {
if (parameter.getType() == ParamType.COEF) {
Node a = parameter.getNodeA();
Node b = parameter.getNodeB();
int aindex = nodes.indexOf(a);
int bindex = nodes.indexOf(b);
double vara = impliedCovar.get(aindex, aindex);
double stda = Math.sqrt(vara);
double varb = impliedCovar.get(bindex, bindex);
double stdb = Math.sqrt(varb);
double oldCoef = im.getEdgeCoef(a, b);
double newCoef = (stda / stdb) * oldCoef;
edgeParameters.put(Edges.directedEdge(a, b), newCoef);
} else if (parameter.getType() == ParamType.COVAR) {
Node a = parameter.getNodeA();
Node b = parameter.getNodeB();
Node exoa = semGraph.getExogenous(a);
Node exob = semGraph.getExogenous(b);
double covar = im.getErrCovar(a, b) / Math.sqrt(im.getErrVar(a) * im.getErrVar(b));
edgeParameters.put(Edges.bidirectedEdge(exoa, exob), covar);
}
}
} else {
// This code estimates the new coefficients from simulated data from the old model.
DataSet dataSet = im.simulateData(1000, false);
TetradMatrix _dataSet = dataSet.getDoubleData();
_dataSet = DataUtils.standardizeData(_dataSet);
DataSet dataSetStandardized = ColtDataSet.makeData(dataSet.getVariables(), _dataSet);
SemEstimator estimator = new SemEstimator(dataSetStandardized, im.getSemPm());
SemIm imStandardized = estimator.estimate();
edgeParameters = new HashMap<Edge, Double>();
for (Parameter parameter : imStandardized.getSemPm().getParameters()) {
if (parameter.getType() == ParamType.COEF) {
Node a = parameter.getNodeA();
Node b = parameter.getNodeB();
double coef = imStandardized.getEdgeCoef(a, b);
edgeParameters.put(Edges.directedEdge(a, b), coef);
} else if (parameter.getType() == ParamType.COVAR) {
Node a = parameter.getNodeA();
Node b = parameter.getNodeB();
Node exoa = semGraph.getExogenous(a);
Node exob = semGraph.getExogenous(b);
double covar = -im.getErrCovar(a, b) / Math.sqrt(im.getErrVar(a) * im.getErrVar(b));
edgeParameters.put(Edges.bidirectedEdge(exoa, exob), covar);
}
}
}
this.measuredNodes = Collections.unmodifiableList(semPm.getMeasuredNodes());
}
