import edu.stanford.nlp.stats.TwoDimensionalCounter; //导入依赖的package包/类
private void loadProbabilities(String filename) throws IOException {
  
if (posDistortionProbabilities != null) return;
posDistortionProbabilities = new TwoDimensionalCounter<String,Integer>();
  
  File file = new File(filename);
  BufferedReader reader = new BufferedReader(new FileReader(file));
  String line = null;
  while ((line = reader.readLine()) != null) {
    String[] parts = line.split(" ");
    int bucket = Integer.parseInt(parts[1]);
    double val = Double.parseDouble(parts[2]);
    posDistortionProbabilities.setCount(parts[0], bucket, Math.log(val));
  }
  reader.close();
}
 

import edu.stanford.nlp.stats.TwoDimensionalCounter; //导入依赖的package包/类
static public void countMWEStatistics(Tree t,
    TwoDimensionalCounter<String, String> unigramTagger,
    TwoDimensionalCounter<String, String> labelPreterm,
    TwoDimensionalCounter<String, String> pretermLabel,
    TwoDimensionalCounter<String, String> labelTerm,
    TwoDimensionalCounter<String, String> termLabel) 
{
  updateTagger(unigramTagger,t);

  //Count MWE statistics
  TregexMatcher m = pMWE.matcher(t);
  while (m.findNextMatchingNode()) {
    Tree match = m.getMatch();
    String label = match.value();
    if(RESOLVE_DUMMY_TAGS && label.equals(FrenchTreeReader.MISSING_PHRASAL))
      continue;
    
    String preterm = Sentence.listToString(match.preTerminalYield());
    String term = Sentence.listToString(match.yield());
    
    labelPreterm.incrementCount(label,preterm);
    pretermLabel.incrementCount(preterm,label);
    labelTerm.incrementCount(label,term);
    termLabel.incrementCount(term, label);
  }
}
 

import edu.stanford.nlp.stats.TwoDimensionalCounter; //导入依赖的package包/类
/**
 * Constructor.
 * 
 * @param input
 */
public OneSidedObjectiveFunction(ClustererState input) {
  // Setup delta data structures
  this.inputState = input;
  localWordToClass = new HashMap<>(input.vocabularySubset.size());
  deltaClassCount = new ClassicCounter<Integer>(input.numClasses);
  deltaClassHistoryCount = new TwoDimensionalCounter<Integer,NgramHistory>();
  for (IString word : input.vocabularySubset) {
    int classId = input.wordToClass.get(word);
    localWordToClass.put(word, classId);
  }
  this.objValue = input.currentObjectiveValue;
}
 

import edu.stanford.nlp.stats.TwoDimensionalCounter; //导入依赖的package包/类
public ClustererState(List<IString> vocabularySubset, Counter<IString> wordCount,
    TwoDimensionalCounter<IString, NgramHistory> historyCount, Map<IString, Integer> inWordToClass,
    Counter<Integer> inClassCount,
    TwoDimensionalCounter<Integer, NgramHistory> inClassHistoryCount, int numClasses, 
    double currentObjectiveValue) {
  this.vocabularySubset = vocabularySubset;
  this.wordCount = wordCount;
  this.historyCount = historyCount;
  this.wordToClass = inWordToClass;
  this.classCount = inClassCount;
  this.classHistoryCount = inClassHistoryCount;
  this.numClasses = numClasses;
  this.currentObjectiveValue = currentObjectiveValue;
}
 

import edu.stanford.nlp.stats.TwoDimensionalCounter; //导入依赖的package包/类
public static void updateTagger(TwoDimensionalCounter<String,String> tagger, 
                                Tree t) {
  List<CoreLabel> yield = t.taggedLabeledYield();
  for(CoreLabel cl : yield) {
    if(RESOLVE_DUMMY_TAGS && cl.tag().equals(FrenchTreeReader.MISSING_POS)) 
      continue;
    else
      tagger.incrementCount(cl.word(), cl.tag());
  }
}
 

import edu.stanford.nlp.stats.TwoDimensionalCounter; //导入依赖的package包/类
public PartialStateUpdate(Map<IString, Integer> wordToClass, Counter<Integer> classCount,
    TwoDimensionalCounter<Integer, NgramHistory> classHistoryCount) {
  this.wordToClass = wordToClass;
  this.deltaClassCount = classCount;
  this.deltaClassHistoryCount = classHistoryCount;
}