コード例 #1
0
  /**
   * 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));
  }
コード例 #2
0
ファイル: Lofs.java プロジェクト: jdramsey/tetrad
  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();
  }
コード例 #3
0
  /**
   * 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);
  }
コード例 #4
0
ファイル: DynamicBin1D.java プロジェクト: jeppe/LinUCB
 /**
  * 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.
 }
コード例 #5
0
  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();
  }
コード例 #6
0
ファイル: DynamicBin1D.java プロジェクト: jeppe/LinUCB
 /** 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();
 }
コード例 #7
0
 /**
  * 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);
 }
コード例 #8
0
ファイル: Lofs.java プロジェクト: jdramsey/tetrad
  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();
  }
コード例 #9
0
ファイル: Lofs.java プロジェクト: jdramsey/tetrad
  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;
  }
コード例 #10
0
ファイル: DynamicBin1D.java プロジェクト: jeppe/LinUCB
 /**
  * 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);
 }