import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
@Override
public double computeSimilarity(Concept c1, Concept c2) {
	if (c1.name.toLowerCase().equals(c2.name.toLowerCase()))
		return 1;

	Set<String> c1Stems = this.stem(c1);
	Set<String> c2Stems = this.stem(c2);

	Set<String> intsect = Sets.intersection(c1Stems, c2Stems);
	Set<String> union = Sets.union(c1Stems, c2Stems);

	double sim = 0;
	if (union.size() == 0)
		sim = 0;
	else
		sim = intsect.size() / (float) union.size();

	return sim;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
@Override
public Map<String, Double> score(JCas jcas) throws AnalysisEngineProcessException {
  List<JCas> views = ViewType.listViews(jcas, viewNamePrefix);
  List<Integer> negativeWordsCounts = new ArrayList<>();
  List<Integer> positiveWordsCounts = new ArrayList<>();
  Map<String, Double> features = new HashMap<>();
  for (JCas view : views) {
    Set<String> tokens = TypeUtil.getOrderedTokens(view).stream().flatMap(
            token -> Stream.of(token.getLemmaForm(), token.getCoveredText().toLowerCase()))
            .collect(toSet());
    Set<String> containedPositiveWords = Sets.intersection(tokens, positiveWords);
    positiveWordsCounts.add(containedPositiveWords.isEmpty() ? 0 : 1);
    containedPositiveWords.forEach(word -> features.put("[email protected]" + word, 1.0));
    Set<String> containedNegativeWords = Sets.intersection(tokens, negativeWords);
    negativeWordsCounts.add(containedNegativeWords.isEmpty() ? 0 : 1);
    containedNegativeWords.forEach(word -> features.put("[email protected]" + word, 1.0));
  }
  features.putAll(YesNoScorer.aggregateFeatures(negativeWordsCounts, "negative-words"));
  features.putAll(YesNoScorer.aggregateFeatures(positiveWordsCounts, "positive-words"));
  return features;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
public ClassicCounter<OUT> lastF1() {
  ClassicCounter<OUT> result = new ClassicCounter<OUT>();
  Set<OUT> keys = Sets.union(previousGuessed.keySet(),previousGold.keySet());
  for(OUT key : keys) {
    result.setCount(key,lastF1(key));
  }
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
public static <E> Counter<E> f1(Counter<E> precision, Counter<E> recall) {
  Counter<E> result = precision.getFactory().create();
  for(E key : Sets.intersection(precision.keySet(),recall.keySet())) {
    result.setCount(key,f1(precision.getCount(key),recall.getCount(key)));
  }
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
/**
 * Returns a counter that is the intersection of c1 and c2.  If both c1 and c2 contain a
 * key, the min of the two counts is used.
 *
 * @return A counter that is the intersection of c1 and c2
 */
public static <E> Counter<E> intersection(Counter<E> c1, Counter<E> c2) {
  Counter<E> result = c1.getFactory().create();
  for (E key : Sets.union(c1.keySet(), c2.keySet())) {
    double count1 = c1.getCount(key);
    double count2 = c2.getCount(key);
    double minCount = (count1 < count2 ? count1 : count2);
    if (minCount > 0) {
      result.setCount(key, minCount);
    }
  }
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
/**
 * Returns the Jaccard Coefficient of the two counters. Calculated as
 * |c1 intersect c2| / ( |c1| + |c2| - |c1 intersect c2|
 *
 * @return The Jaccard Coefficient of the two counters
 */
public static <E> double jaccardCoefficient(Counter<E> c1, Counter<E> c2) {
  double minCount = 0.0, maxCount = 0.0;
  for (E key : Sets.union(c1.keySet(), c2.keySet())) {
    double count1 = c1.getCount(key);
    double count2 = c2.getCount(key);
    minCount += (count1 < count2 ? count1 : count2);
    maxCount += (count1 > count2 ? count1 : count2);
  }
  return minCount / maxCount;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
/**
 * Returns the product of c1 and c2.
 *
 * @return The product of c1 and c2.
 */
public static <E> Counter<E> product(Counter<E> c1, Counter<E> c2) {
  Counter<E> result = c1.getFactory().create();
  for (E key : Sets.intersection(c1.keySet(), c2.keySet())) {
    result.setCount(key, c1.getCount(key) * c2.getCount(key));
  }
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
/**
 * Returns |c1 - c2|.
 *
 * @return The difference between sets c1 and c2.
 */
public static <E> Counter<E> absoluteDifference(Counter<E> c1, Counter<E> c2) {
  Counter<E> result = c1.getFactory().create();
  for (E key : Sets.union(c1.keySet(), c2.keySet())) {
    double newCount = Math.abs(c1.getCount(key) - c2.getCount(key));
    if (newCount > 0) {
      result.setCount(key, newCount);
    }
  }
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
/**
 * Returns c1 divided by c2.  Note that this can create NaN if c1 has non-zero counts for keys that
 * c2 has zero counts.
 *
 * @return c1 divided by c2.
 */
public static <E> Counter<E> division(Counter<E> c1, Counter<E> c2) {
  Counter<E> result = c1.getFactory().create();
  for (E key : Sets.union(c1.keySet(), c2.keySet())) {
    result.setCount(key, c1.getCount(key) / c2.getCount(key));
  }
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
public static <T> Counter<T> diff(Counter<T> goldFeatures, Counter<T> guessedFeatures) {
  Counter<T> result = goldFeatures.getFactory().create();
  for (T key : Sets.union(goldFeatures.keySet(), guessedFeatures.keySet())) {
    result.setCount(key, goldFeatures.getCount(key) - guessedFeatures.getCount(key));
  }
  retainNonZeros(result);
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
/**
 * Returns a counter that is the intersection of c1 and c2. If both c1 and c2
 * contain a key, the min of the two counts is used.
 *
 * @return A counter that is the intersection of c1 and c2
 */
public static <E> Counter<E> intersection(Counter<E> c1, Counter<E> c2) {
  Counter<E> result = c1.getFactory().create();
  for (E key : Sets.union(c1.keySet(), c2.keySet())) {
    double count1 = c1.getCount(key);
    double count2 = c2.getCount(key);
    double minCount = (count1 < count2 ? count1 : count2);
    if (minCount > 0) {
      result.setCount(key, minCount);
    }
  }
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
/**
 * Returns the Jaccard Coefficient of the two counters. Calculated as |c1
 * intersect c2| / ( |c1| + |c2| - |c1 intersect c2|
 *
 * @return The Jaccard Coefficient of the two counters
 */
public static <E> double jaccardCoefficient(Counter<E> c1, Counter<E> c2) {
  double minCount = 0.0, maxCount = 0.0;
  for (E key : Sets.union(c1.keySet(), c2.keySet())) {
    double count1 = c1.getCount(key);
    double count2 = c2.getCount(key);
    minCount += (count1 < count2 ? count1 : count2);
    maxCount += (count1 > count2 ? count1 : count2);
  }
  return minCount / maxCount;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
public static <E> Counter<E> add(Counter<E> c1, Counter<E> c2) {
  Counter<E> result = c1.getFactory().create();
  for (E key : Sets.union(c1.keySet(), c2.keySet())) {
    result.setCount(key, c1.getCount(key) + c2.getCount(key));
  }
  retainNonZeros(result);
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
/**
 * Returns c1 divided by c2. Note that this can create NaN if c1 has non-zero
 * counts for keys that c2 has zero counts.
 *
 * @return c1 divided by c2.
 */
public static <E> Counter<E> division(Counter<E> c1, Counter<E> c2) {
  Counter<E> result = c1.getFactory().create();
  for (E key : Sets.union(c1.keySet(), c2.keySet())) {
    result.setCount(key, c1.getCount(key) / c2.getCount(key));
  }
  return result;
}
 

import edu.stanford.nlp.util.Sets; //导入依赖的package包/类
private static boolean isContextOverlapping(Mention m1, Mention m2) {
  Set<String> context1 = Generics.newHashSet();
  Set<String> context2 = Generics.newHashSet();
  context1.addAll(m1.getContext());
  context2.addAll(m2.getContext());
  return Sets.intersects(context1, context2);
}