org.apache.lucene.search.similarities.Similarity.SimScorer Java Examples

@Override
public FunctionValues getValues(Map<Object, Object> context, LeafReaderContext readerContext) throws IOException {
  IndexSearcher searcher = (IndexSearcher)context.get("searcher");
  final TFIDFSimilarity similarity = IDFValueSource.asTFIDF(searcher.getSimilarity(), field);
  if (similarity == null) {
    throw new UnsupportedOperationException("requires a TFIDFSimilarity (such as ClassicSimilarity)");
  }
  // Only works if the contribution of the tf is 1 when the freq is 1 and contribution of the idf
  // is 1 when docCount == docFreq == 1
  final SimScorer simScorer = similarity.scorer(1f,
      new CollectionStatistics(field, 1, 1, 1, 1),
      new TermStatistics(new BytesRef("bogus"), 1, 1));
  final LeafSimScorer leafSimScorer = new LeafSimScorer(simScorer, readerContext.reader(), field, true);
  
  return new FloatDocValues(this) {
    int lastDocID = -1;
    @Override
    public float floatVal(int docID) throws IOException {
      if (docID < lastDocID) {
        throw new AssertionError("docs out of order: lastDocID=" + lastDocID + " docID=" + docID);
      }
      lastDocID = docID;
      return leafSimScorer.score(docID, 1f);
    }
  };
}
 

ExactPhraseMatcher(PhraseQuery.PostingsAndFreq[] postings, ScoreMode scoreMode, SimScorer scorer, float matchCost) {
  super(matchCost);

  final DocIdSetIterator approximation = ConjunctionDISI.intersectIterators(Arrays.stream(postings).map(p -> p.postings).collect(Collectors.toList()));
  final ImpactsSource impactsSource = mergeImpacts(Arrays.stream(postings).map(p -> p.impacts).toArray(ImpactsEnum[]::new));

  if (scoreMode == ScoreMode.TOP_SCORES) {
    this.approximation = this.impactsApproximation = new ImpactsDISI(approximation, impactsSource, scorer);
  } else {
    this.approximation = approximation;
    this.impactsApproximation = new ImpactsDISI(approximation, impactsSource, scorer);
  }

  List<PostingsAndPosition> postingsAndPositions = new ArrayList<>();
  for(PhraseQuery.PostingsAndFreq posting : postings) {
    postingsAndPositions.add(new PostingsAndPosition(posting.postings, posting.position));
  }
  this.postings = postingsAndPositions.toArray(new PostingsAndPosition[postingsAndPositions.size()]);
}
 

/**
 * Sole constructor: Score documents of {@code reader} with {@code scorer}.
 *
 */
MultiNormsLeafSimScorer(SimScorer scorer, LeafReader reader, Collection<FieldAndWeight> normFields, boolean needsScores) throws IOException {
  this.scorer = Objects.requireNonNull(scorer);
  if (needsScores) {
    final List<NumericDocValues> normsList = new ArrayList<>();
    final List<Float> weightList = new ArrayList<>();
    for (FieldAndWeight field : normFields) {
      NumericDocValues norms = reader.getNormValues(field.field);
      if (norms != null) {
        normsList.add(norms);
        weightList.add(field.weight);
      }
    }
    if (normsList.isEmpty()) {
      norms = null;
    } else if (normsList.size() == 1) {
      norms = normsList.get(0);
    } else {
      final NumericDocValues[] normsArr = normsList.toArray(new NumericDocValues[0]);
      final float[] weightArr = new float[normsList.size()];
      for (int i = 0; i < weightList.size(); i++) {
        weightArr[i] = weightList.get(i);
      }
      norms = new MultiFieldNormValues(normsArr, weightArr);
    }
  } else {
    norms = null;
  }
}
 

@Override
public PhraseCountScorer scorer(LeafReaderContext context) throws IOException {
  final Spans spans = getSpans(context, Postings.POSITIONS);
  if (spans == null) {
    return null;
  }
  final SimScorer docScorer = getSimScorer(context);
  return new PhraseCountScorer(this, spans, docScorer, weightedCount);
}
 

/**
 * Sole constructor.
 */
public MaxScoreCache(ImpactsSource impactsSource, SimScorer scorer) {
  this.impactsSource = impactsSource;
  this.scorer = scorer;
  maxScoreCache = new float[0];
  maxScoreCacheUpTo = new int[0];
}
 

/**
 * Sole constructor.
 * @param in            wrapped iterator
 * @param impactsSource source of impacts
 * @param scorer        scorer
 */
public ImpactsDISI(DocIdSetIterator in, ImpactsSource impactsSource, SimScorer scorer) {
  this.in = in;
  this.impactsSource = impactsSource;
  this.maxScoreCache = new MaxScoreCache(impactsSource, scorer);
  this.globalMaxScore = scorer.score(Float.MAX_VALUE, 1L);
}
 

private void doTestSimScorer(SimScorer s) {
  float maxScore = s.score(Float.MAX_VALUE, 1);
  assertTrue(Float.isFinite(maxScore)); // used to compute max scores
  // Test that the score doesn't decrease with freq
  for (int freq = 2; freq < 65536; ++freq) {
    assertTrue(s.score(freq - 1, 1L) <= s.score(freq, 1L));
  }
  assertTrue(s.score(65535, 1L) <= maxScore);
}
 

@Override
SimScorer scorer(float weight) {
  return new SimScorer() {
    @Override
    public float score(float freq, long norm) {
      return (float) (weight * Math.log(scalingFactor + decodeFeatureValue(freq)));
    }
  };
}
 

@Override
SimScorer scorer(float weight) {
  return new SimScorer() {
    @Override
    public float score(float freq, long norm) {
      float f = decodeFeatureValue(freq);
      // should be f^a / (f^a + k^a) but we rewrite it to
      // 1 - k^a / (f + k^a) to make sure it doesn't decrease
      // with f in spite of rounding
      return (float) (weight * (1 - pivotPa / (Math.pow(f, a) + pivotPa)));
    }
  };
}
 

/** Return the wrapped {@link SimScorer}. */
public SimScorer getSimScorer() {
  return scorer;
}
 

@Override
public SimScorer getSimScorer(LeafReaderContext context) {
  return new MtasSimScorer();
}
 

@Override
public SimScorer getSimScorer(LeafReaderContext context) {
  return new MtasSimScorer();
}
 

@Override
public SimScorer getSimScorer(LeafReaderContext context) {
  return new MtasSimScorer();
}
 

AllTermScorer(Weight weight, PostingsEnum postings, Similarity.SimScorer docScorer) {
    super(weight);
    this.postings = postings;
    this.docScorer = docScorer;
}
 

/**
 * Sole constructor: Score documents of {@code reader} with {@code scorer}.
 */
public LeafSimScorer(SimScorer scorer, LeafReader reader, String field, boolean needsScores) throws IOException {
  this.scorer = Objects.requireNonNull(scorer);
  norms = needsScores ? reader.getNormValues(field) : null;
}
 

/**
 * Return a SimScorer for this context
 * @param context the LeafReaderContext
 * @return a SimWeight
 * @throws IOException on error
 */
public SimScorer getSimScorer(LeafReaderContext context) throws IOException {
  return simWeight == null ? null : similarity.simScorer(simWeight, context);
}
 

abstract SimScorer scorer(float w); 

protected abstract PhraseMatcher getPhraseMatcher(LeafReaderContext context, SimScorer scorer, boolean exposeOffsets) throws IOException; 

protected abstract Similarity.SimScorer getStats(IndexSearcher searcher) throws IOException;