/** * Computes the specified quantile elements over the values previously added. * * @param phis the quantiles for which elements are to be computed. Each phi must be in the * interval (0.0,1.0]. <tt>phis</tt> must be sorted ascending. * @return the approximate quantile elements. */ public DoubleArrayList quantileElements(DoubleArrayList phis) { if (precomputeEpsilon <= 0.0) return super.quantileElements(phis); int quantilesToPrecompute = (int) Utils.epsilonCeiling(1.0 / precomputeEpsilon); /* * if (phis.size() > quantilesToPrecompute) { // illegal use case! // we * compute results, but loose explicit approximation guarantees. return * super.quantileElements(phis); } */ // select that quantile from the precomputed set that corresponds to a // position closest to phi. phis = phis.copy(); double e = precomputeEpsilon; for (int index = phis.size(); --index >= 0; ) { double phi = phis.get(index); int i = (int) Math.round(((2.0 * phi / e) - 1.0) / 2.0); // finds // closest i = Math.min(quantilesToPrecompute - 1, Math.max(0, i)); double augmentedPhi = (e / 2.0) * (1 + 2 * i); phis.set(index, augmentedPhi); } return super.quantileElements(phis); }
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 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; }