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();
}
private double[] dependencePvalsLinear(Node x, Node y, List<Node> z) {
if (!variablesPerNode.containsKey(x)) {
throw new IllegalArgumentException("Unrecogized node: " + x);
}
if (!variablesPerNode.containsKey(y)) {
throw new IllegalArgumentException("Unrecogized node: " + y);
}
for (Node node : z) {
if (!variablesPerNode.containsKey(node)) {
throw new IllegalArgumentException("Unrecogized node: " + node);
}
}
List<Node> yzDumList = new ArrayList<>();
List<Node> yzList = new ArrayList<>();
yzList.add(y);
yzList.addAll(z);
// List<Node> zList = new ArrayList<>();
yzDumList.addAll(variablesPerNode.get(y));
for (Node _z : z) {
yzDumList.addAll(variablesPerNode.get(_z));
// zList.addAll(variablesPerNode.get(_z));
}
int[] _rows = getNonMissingRows(x, y, z);
regression.setRows(_rows);
RegressionResult result;
try {
result = regression.regress(x, yzDumList);
} catch (Exception e) {
return null;
}
double[] pVec = new double[yzList.size()];
double[] pCoef = result.getP();
// skip intercept at 0
int coeffInd = 1;
for (int i = 0; i < pVec.length; i++) {
List<Node> curDummy = variablesPerNode.get(yzList.get(i));
if (curDummy.size() == 1) {
pVec[i] = pCoef[coeffInd];
coeffInd++;
continue;
} else {
pVec[i] = 0;
}
for (Node n : curDummy) {
pVec[i] += Math.log(pCoef[coeffInd]);
coeffInd++;
}
if (pVec[i] == Double.NEGATIVE_INFINITY) pVec[i] = 0.0;
else
pVec[i] =
1.0
- new ChiSquaredDistribution(2 * curDummy.size())
.cumulativeProbability(-2 * pVec[i]);
}
return pVec;
}
private double andersonDarlingPASquareStarB(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);
}
double sum = 0.0;
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)));
// By centering the individual residual columns, all moments of the mixture become weighted
// averages of the moments
// of the individual columns.
// http://en.wikipedia.org/wiki/Mixture_distribution#Finite_and_countable_mixtures
for (int i2 = 0; i2 < _residualsSingleDataset.size(); i2++) {
// _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2) - mean) /
// std);
// _residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2)) / std);
if (isMeanCenterResiduals()) {
_residualsSingleDataset.set(i2, (_residualsSingleDataset.get(i2) - mean));
}
}
double[] _f = new double[_residuals.size()];
for (int k = 0; k < _residuals.size(); k++) {
_f[k] = _residuals.get(k);
}
sum += new AndersonDarlingTest(_f).getASquaredStar();
}
return sum / dataSets.size();
}
private double localScoreB(Node node, List<Node> parents) {
double score = 0.0;
double maxScore = Double.NEGATIVE_INFINITY;
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();
DoubleArrayList _residualsSingleDataset =
new DoubleArrayList(residualsSingleDataset.toArray());
for (int h = 0; h < residualsSingleDataset.size(); h++) {
if (Double.isNaN(residualsSingleDataset.get(h))) {
continue DATASET;
}
}
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);
}
double[] _f = new double[_residualsSingleDataset.size()];
for (int k = 0; k < _residualsSingleDataset.size(); k++) {
_f[k] = _residualsSingleDataset.get(k);
}
DoubleArrayList f = new DoubleArrayList(_f);
for (int k = 0; k < f.size(); k++) {
f.set(k, Math.abs(f.get(k)));
}
double _mean = Descriptive.mean(f);
double diff = _mean - Math.sqrt(2.0 / Math.PI);
score += diff * diff;
if (score > maxScore) {
maxScore = score;
}
}
double avg = score / dataSets.size();
return avg;
}
