/**
* 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) {
/*
//check parameter
DoubleArrayList sortedPhiList = phis.copy();
sortedPhiList.sort();
if (! phis.equals(sortedPhiList)) {
throw new IllegalArgumentException("Phis must be sorted ascending.");
}
*/
// System.out.println("starting to augment missing values, if necessary...");
phis = preProcessPhis(phis);
long[] triggerPositions = new long[phis.size()];
long totalSize = this.bufferSet.totalSize();
for (int i = phis.size(); --i >= 0; ) {
triggerPositions[i] = Utils.epsilonCeiling(phis.get(i) * totalSize) - 1;
}
// System.out.println("triggerPositions="+cern.colt.Arrays.toString(triggerPositions));
// System.out.println("starting to determine quantiles...");
// System.out.println(bufferSet);
DoubleBuffer[] fullBuffers = bufferSet._getFullOrPartialBuffers();
double[] quantileElements = new double[phis.size()];
// do the main work: determine values at given positions in sorted sequence
return new DoubleArrayList(bufferSet.getValuesAtPositions(fullBuffers, triggerPositions));
}
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();
}
/**
* 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);
}
/**
* Returns the number of elements contained in the receiver.
*
* @returns the number of elements contained in the receiver.
*/
public synchronized int size() {
return elements.size();
// Never ever use "this.size" as it would be intuitive!
// This class abuses "this.size". "this.size" DOES NOT REFLECT the number of elements contained
// in the receiver!
// Instead, "this.size" reflects the number of elements incremental stats computation has
// already processed.
}
public void samplesToString(DoubleArrayList theta) {
int cols = theta.size();
sampleString = "";
for (int param = 0; param < (cols - 1); ++param) {
sampleString = sampleString + Double.toString(theta.getQuick(param)) + ", ";
// thetaSamples.set(sampleLoc, param, thetaEstNow.get(param));
}
sampleString = sampleString + Double.toString(theta.getQuick(cols - 1));
// System.out.println();
}
/** Returns a String representation of the receiver. */
public synchronized String toString() {
StringBuffer buf = new StringBuffer(super.toString());
DoubleArrayList distinctElements = new DoubleArrayList();
IntArrayList frequencies = new IntArrayList();
frequencies(distinctElements, frequencies);
if (distinctElements.size() < 100) { // don't cause unintended floods
buf.append("Distinct elements: " + distinctElements + "\n");
buf.append("Frequencies: " + frequencies + "\n");
} else {
buf.append("Distinct elements & frequencies not printed (too many).");
}
return buf.toString();
}
/**
* Adds all values of the specified list to the receiver.
*
* @param values the list of which all values shall be added.
*/
public void addAllOf(DoubleArrayList values) {
addAllOfFromTo(values, 0, values.size() - 1);
}
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;
}
/**
* Removes the <tt>s</tt> smallest and <tt>l</tt> largest elements from the receiver. The
* receivers size will be reduced by <tt>s + l</tt> elements.
*
* @param s the number of smallest elements to trim away (<tt>s >= 0</tt>).
* @param l the number of largest elements to trim away (<tt>l >= 0</tt>).
*/
public synchronized void trim(int s, int l) {
DoubleArrayList elems = sortedElements();
clear();
addAllOfFromTo(elems, s, elems.size() - 1 - l);
}