import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
/** Get the exact k best parses for the sentence.
 *
 *  @param k The number of best parses to return
 *  @return The exact k best parses for the sentence, with
 *         each accompanied by its score (typically a
 *         negative log probability).
 */
public List<ScoredObject<Tree>> getKBestParses(int k) {

  cand = new HashMap<Vertex,PriorityQueue<Derivation>>();
  dHat = new HashMap<Vertex,LinkedList<Derivation>>();

  int start = 0;
  int end = length;
  int goal = stateNumberer.number(goalStr);

  Vertex v = new Vertex(goal, start, end);
  List<ScoredObject<Tree>> kBestTrees = new ArrayList<ScoredObject<Tree>>();
  for (int i = 1; i <= k; i++) {
    Tree internalTree = getTree(v, i, k);
    if (internalTree == null) { break; }
    // restoreUnaries(internalTree);
    kBestTrees.add(new ScoredObject<Tree>(internalTree, dHat.get(v).get(i-1).score));
  }
  return kBestTrees;
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
private void lazyKthBest(Vertex v, int k, int kPrime) {
  PriorityQueue<Derivation> candV = getCandidates(v, kPrime);

  LinkedList<Derivation> dHatV = dHat.get(v);
  if (dHatV == null) {
    dHatV = new LinkedList<Derivation>();
    dHat.put(v,dHatV);
  }
  while (dHatV.size() < k) {
    if ( ! dHatV.isEmpty()) {
      Derivation derivation = dHatV.getLast();
      lazyNext(candV, derivation, kPrime);
    }
    if ( ! candV.isEmpty()) {
      Derivation d = candV.removeFirst();
      dHatV.add(d);
    } else {
      break;
    }
  }
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
/**
 * Returns a <code>String</code> representation of the <code>k</code> keys
 * with the largest counts in the given {@link Counter}, using the given
 * format string.
 *
 * @param c a Counter
 * @param k how many keys to print
 * @param fmt a format string, such as "%.0f\t%s" (do not include final "%n")
 * @param swap whether the count should appear after the key
 */
public static <E> String toVerticalString(Counter<E> c, int k, String fmt, boolean swap) {
  PriorityQueue<E> q = Counters.toPriorityQueue(c);
  List<E> sortedKeys = q.toSortedList();
  StringBuilder sb = new StringBuilder();
  int i = 0;
  for (Iterator<E> keyI = sortedKeys.iterator(); keyI.hasNext() && i < k; i++) {
    E key = keyI.next();
    double val = q.getPriority(key);
    if (swap) {
      sb.append(String.format(fmt, key, val));
    } else {
      sb.append(String.format(fmt, val, key));
    }
    if (keyI.hasNext()) {
      sb.append('\n');
    }
  }
  return sb.toString();
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
/**
 * Returns a <code>String</code> representation of the <code>k</code> keys
 * with the largest counts in the given {@link Counter}, using the given
 * format string.
 *
 * @param c
 *          a Counter
 * @param k
 *          how many keys to print
 * @param fmt
 *          a format string, such as "%.0f\t%s" (do not include final "%n")
 * @param swap
 *          whether the count should appear after the key
 */
public static <E> String toVerticalString(Counter<E> c, int k, String fmt, boolean swap) {
  PriorityQueue<E> q = Counters.toPriorityQueue(c);
  List<E> sortedKeys = q.toSortedList();
  StringBuilder sb = new StringBuilder();
  int i = 0;
  for (Iterator<E> keyI = sortedKeys.iterator(); keyI.hasNext() && i < k; i++) {
    E key = keyI.next();
    double val = q.getPriority(key);
    if (swap) {
      sb.append(String.format(fmt, key, val));
    } else {
      sb.append(String.format(fmt, val, key));
    }
    if (keyI.hasNext()) {
      sb.append('\n');
    }
  }
  return sb.toString();
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
public void init(List<Pair<Double, Integer>> dataScores) {
  PriorityQueue<Pair<Integer, Pair<Double, Integer>>> q = new BinaryHeapPriorityQueue<Pair<Integer, Pair<Double, Integer>>>();
  for (int i = 0; i < dataScores.size(); i++) {
    q.add(new Pair<Integer, Pair<Double, Integer>>(Integer.valueOf(i), dataScores.get(i)), -dataScores.get(i).first().doubleValue());
  }
  List<Pair<Integer, Pair<Double, Integer>>> sorted = q.toSortedList();
  scores = new double[sorted.size()];
  classes = new int[sorted.size()];
  System.err.println("incoming size " + dataScores.size() + " resulting " + sorted.size());

  for (int i = 0; i < sorted.size(); i++) {
    Pair<Double, Integer> next = sorted.get(i).second();
    scores[i] = next.first().doubleValue();
    classes[i] = next.second().intValue();
  }
  init();
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
public void initMC(ArrayList<Triple<Double, Integer, Integer>> dataScores) {
  PriorityQueue<Pair<Integer, Triple<Double, Integer, Integer>>> q = new BinaryHeapPriorityQueue<Pair<Integer, Triple<Double, Integer, Integer>>>();
  for (int i = 0; i < dataScores.size(); i++) {
    q.add(new Pair<Integer, Triple<Double, Integer, Integer>>(Integer.valueOf(i), dataScores.get(i)), -dataScores.get(i).first().doubleValue());
  }
  List<Pair<Integer, Triple<Double, Integer, Integer>>> sorted = q.toSortedList();
  scores = new double[sorted.size()];
  classes = new int[sorted.size()];
  guesses = new int[sorted.size()];
  System.err.println("incoming size " + dataScores.size() + " resulting " + sorted.size());

  for (int i = 0; i < sorted.size(); i++) {
    Triple<Double, Integer, Integer> next = sorted.get(i).second();
    scores[i] = next.first().doubleValue();
    classes[i] = next.second().intValue();
    guesses[i] = next.third().intValue();
  }
  init();
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
private void lazyKthBest(Vertex v, int k, int kPrime) {
  PriorityQueue<Derivation> candV = getCandidates(v, kPrime);

  LinkedList<Derivation> dHatV = dHat.get(v);
  if (dHatV == null) {
    dHatV = new LinkedList<Derivation>();
    dHat.put(v,dHatV);
  }
  while (dHatV.size() < k) {
    if (!dHatV.isEmpty()) {
      Derivation derivation = dHatV.getLast();
      lazyNext(candV, derivation, kPrime);
    }
    if (!candV.isEmpty()) {
      Derivation d = candV.removeFirst();
      dHatV.add(d);
    } else {
      break;
    }
  }
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
/** Get the exact k best parses for the sentence.
 *
 *  @param k The number of best parses to return
 *  @return The exact k best parses for the sentence, with
 *         each accompanied by its score (typically a
 *         negative log probability).
 */
public List<ScoredObject<Tree>> getKBestParses(int k) {

  cand = new HashMap<Vertex,PriorityQueue<Derivation>>();
  dHat = new HashMap<Vertex,LinkedList<Derivation>>();

  int start = 0;
  int end = length;
  int goal = stateIndex.indexOf(goalStr);

  Vertex v = new Vertex(goal, start, end);
  List<ScoredObject<Tree>> kBestTrees = new ArrayList<ScoredObject<Tree>>();
  for (int i = 1; i <= k; i++) {
    Tree internalTree = getTree(v, i, k);
    if (internalTree == null) { break; }
    // restoreUnaries(internalTree);
    kBestTrees.add(new ScoredObject<Tree>(internalTree, dHat.get(v).get(i-1).score));
  }
  return kBestTrees;
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
/**
 * Returns a {@link edu.stanford.nlp.util.PriorityQueue} whose elements
 * are the keys of Counter c,
 * and the score of each key in c becomes its priority.
 *
 * @param c Input Counter
 * @return A PriorityQueue where the count is a key's priority
 */
// TODO: rewrite to use entrySet()
public static <E> edu.stanford.nlp.util.PriorityQueue<E> toPriorityQueue(Counter<E> c) {
  edu.stanford.nlp.util.PriorityQueue<E> queue = new BinaryHeapPriorityQueue<E>();
  for (E key : c.keySet()) {
    double count = c.getCount(key);
    queue.add(key, count);
  }
  return queue;
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
public static <E> String toBiggestValuesFirstString(Counter<E> c, int k) {
    PriorityQueue<E> pq = toPriorityQueue(c);
    PriorityQueue<E> largestK = new BinaryHeapPriorityQueue<E>();
    //TODO: Is there any reason the original (commented out) line is better than the one replacing it?
//    while (largestK.size() < k && ((Iterator<E>)pq).hasNext()) {
    while (largestK.size() < k && !pq.isEmpty()) {
      double firstScore = pq.getPriority(pq.getFirst());
      E first = pq.removeFirst();
      largestK.changePriority(first, firstScore);
    }
    return largestK.toString();
  }
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
/**
 * Returns a {@link edu.stanford.nlp.util.PriorityQueue} whose elements are
 * the keys of Counter c, and the score of each key in c becomes its priority.
 *
 * @param c
 *          Input Counter
 * @return A PriorityQueue where the count is a key's priority
 */
// TODO: rewrite to use entrySet()
public static <E> edu.stanford.nlp.util.PriorityQueue<E> toPriorityQueue(Counter<E> c) {
  edu.stanford.nlp.util.PriorityQueue<E> queue = new BinaryHeapPriorityQueue<E>();
  for (E key : c.keySet()) {
    double count = c.getCount(key);
    queue.add(key, count);
  }
  return queue;
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
public static <E> String toBiggestValuesFirstString(Counter<E> c, int k) {
  PriorityQueue<E> pq = toPriorityQueue(c);
  PriorityQueue<E> largestK = new BinaryHeapPriorityQueue<E>();
  // TODO: Is there any reason the original (commented out) line is better
  // than the one replacing it?
  // while (largestK.size() < k && ((Iterator<E>)pq).hasNext()) {
  while (largestK.size() < k && !pq.isEmpty()) {
    double firstScore = pq.getPriority(pq.getFirst());
    E first = pq.removeFirst();
    largestK.changePriority(first, firstScore);
  }
  return largestK.toString();
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
/**
 * Retains the minimal set of top keys such that their count sum is more than thresholdCount. 
 * @param counter
 * @param thresholdCount
 */
public static<E> void retainTopMass(Counter<E> counter, double thresholdCount){
  PriorityQueue<E> queue = Counters.toPriorityQueue(counter);
  counter.clear();
  
  double mass = 0;
  while (mass < thresholdCount && !queue.isEmpty()) {
    double value = queue.getPriority();
    E key = queue.removeFirst();  
    counter.setCount(key, value);
    mass += value;
  }
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
public static<E> List<E> topKeys(Counter<E> t, int topNum){
  List<E> list = new ArrayList<E>();
  PriorityQueue<E> q = Counters.toPriorityQueue(t);
  int num = 0;
  while(!q.isEmpty() && num < topNum){
   num++;
   list.add(q.removeFirst());
  }
  return list;
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
public static<E> List<Pair<E, Double>> topKeysWithCounts(Counter<E> t, int topNum){
  List<Pair<E, Double>> list = new ArrayList<Pair<E, Double>>();
  PriorityQueue<E> q = Counters.toPriorityQueue(t);
  int num = 0;
  while(!q.isEmpty() && num < topNum){
   num++;
   E k = q.removeFirst();
   list.add(new Pair<E, Double>(k, t.getCount(k)));
  }
  return list;
}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
public <F> void initMC(ProbabilisticClassifier<L,F> classifier, GeneralDataset<L,F> data) {
  //if (!(gData instanceof Dataset)) {
  //  throw new UnsupportedOperationException("Can only handle Datasets, not "+gData.getClass().getName());
  //}
  //
  //Dataset data = (Dataset)gData;

  PriorityQueue<Pair<Integer, Pair<Double, Boolean>>> q = new BinaryHeapPriorityQueue<Pair<Integer, Pair<Double, Boolean>>>();
  total = 0;
  correct = 0;
  logLikelihood = 0.0;
  for (int i = 0; i < data.size(); i++) {
    Datum<L,F> d = data.getRVFDatum(i);
    Counter<L> scores = classifier.logProbabilityOf(d);
    L guess = Counters.argmax(scores);
    L correctLab = d.label();
    double guessScore = scores.getCount(guess);
    double correctScore = scores.getCount(correctLab);
    int guessInd = data.labelIndex().indexOf(guess);
    int correctInd = data.labelIndex().indexOf(correctLab);

    total++;
    if (guessInd == correctInd) {
      correct++;
    }
    logLikelihood += correctScore;
    q.add(new Pair<Integer, Pair<Double, Boolean>>(Integer.valueOf(i), new Pair<Double, Boolean>(new Double(guessScore), Boolean.valueOf(guessInd == correctInd))), -guessScore);
  }
  accuracy = (double) correct / (double) total;
  List<Pair<Integer, Pair<Double, Boolean>>> sorted = q.toSortedList();
  scores = new double[sorted.size()];
  isCorrect = new boolean[sorted.size()];

  for (int i = 0; i < sorted.size(); i++) {
    Pair<Double, Boolean> next = sorted.get(i).second();
    scores[i] = next.first().doubleValue();
    isCorrect[i] = next.second().booleanValue();
  }

}
 

import edu.stanford.nlp.util.PriorityQueue; //导入依赖的package包/类
public static void main(String[] args) {

    PriorityQueue<String> q = new BinaryHeapPriorityQueue<String>();
    q.add("bla", 2);
    q.add("bla3", 2);
    System.err.println("size of q " + q.size());

    PRCurve pr = new PRCurve("c:/data0204/precsvm", true);
    System.err.println("acc " + pr.accuracy() + " opt " + pr.optimalAccuracy() + " cwa " + pr.cwa() + " optcwa " + pr.optimalCwa());
    for (int r = 1; r <= pr.numSamples(); r++) {
      System.err.println("optimal precision at recall " + r + " " + pr.precision(r));
      System.err.println("model precision at recall " + r + " " + pr.logPrecision(r));
    }
  }