public override void SetScorer(Scorer scorer) { // Set a ScoreCachingWrappingScorer in case the wrapped Collector will call // score() also. this.scorer = new ScoreCachingWrappingScorer(scorer); c.SetScorer(this.scorer); }
public ConjunctionScorer(Similarity similarity, Scorer[] scorers):base(similarity) { this.scorers = scorers; coord = similarity.Coord(scorers.Length, scorers.Length); for (int i = 0; i < scorers.Length; i++) { if (scorers[i].NextDoc() == NO_MORE_DOCS) { // If even one of the sub-scorers does not have any documents, this // scorer should not attempt to do any more work. lastDoc = NO_MORE_DOCS; return ; } } // Sort the array the first time... // We don't need to sort the array in any future calls because we know // it will already start off sorted (all scorers on same doc). // note that this comparator is not consistent with equals! System.Array.Sort(scorers, new AnonymousClassComparator(this)); // NOTE: doNext() must be called before the re-sorting of the array later on. // The reason is this: assume there are 5 scorers, whose first docs are 1, // 2, 3, 5, 5 respectively. Sorting (above) leaves the array as is. Calling // doNext() here advances all the first scorers to 5 (or a larger doc ID // they all agree on). // However, if we re-sort before doNext() is called, the order will be 5, 3, // 2, 1, 5 and then doNext() will stop immediately, since the first scorer's // docs equals the last one. So the invariant that after calling doNext() // all scorers are on the same doc ID is broken. if (DoNext() == NO_MORE_DOCS) { // The scorers did not agree on any document. lastDoc = NO_MORE_DOCS; return ; } // If first-time skip distance is any predictor of // scorer sparseness, then we should always try to skip first on // those scorers. // Keep last scorer in it's last place (it will be the first // to be skipped on), but reverse all of the others so that // they will be skipped on in order of original high skip. int end = scorers.Length - 1; int max = end >> 1; for (int i = 0; i < max; i++) { Scorer tmp = scorers[i]; int idx = end - i - 1; scorers[i] = scorers[idx]; scorers[idx] = tmp; } }
/// <summary> Creates a new instance of DisjunctionMaxScorer /// /// </summary> /// <param name="tieBreakerMultiplier">Multiplier applied to non-maximum-scoring subqueries for a /// document as they are summed into the result. /// </param> /// <param name="similarity">-- not used since our definition involves neither coord nor terms /// directly /// </param> /// <param name="subScorers">The sub scorers this Scorer should iterate on /// </param> /// <param name="numScorers">The actual number of scorers to iterate on. Note that the array's /// length may be larger than the actual number of scorers. /// </param> public DisjunctionMaxScorer(float tieBreakerMultiplier, Similarity similarity, Scorer[] subScorers, int numScorers):base(similarity) { this.tieBreakerMultiplier = tieBreakerMultiplier; // The passed subScorers array includes only scorers which have documents // (DisjunctionMaxQuery takes care of that), and their nextDoc() was already // called. this.subScorers = subScorers; this.numScorers = numScorers; Heapify(); }
public override void SetScorer(Scorer scorer) { // wrap with a ScoreCachingWrappingScorer so that successive calls to // score() will not incur score computation over and over again. this.scorer = new ScoreCachingWrappingScorer(scorer); }
public override void SetScorer(Scorer scorer) { this.scorer = scorer; }
public override void SetScorer(Scorer scorer) { collector.SetScorer(scorer); }
/// <summary> Called before successive calls to {@link #Collect(int)}. Implementations /// that need the score of the current document (passed-in to /// {@link #Collect(int)}), should save the passed-in Scorer and call /// scorer.score() when needed. /// </summary> public abstract void SetScorer(Scorer scorer);
public override void SetScorer(Scorer scorer) { // set the scorer on all comparators for (int i = 0; i < comparators.Length; i++) { comparators[i].SetScorer(scorer); } }
private Scorer DualConjunctionSumScorer(Scorer req1, Scorer req2) { // non counting. return new ConjunctionScorer(defaultSimilarity, new Scorer[]{req1, req2}); // All scorers match, so defaultSimilarity always has 1 as // the coordination factor. // Therefore the sum of the scores of two scorers // is used as score. }
internal SingleMatchScorer(BooleanScorer2 enclosingInstance, Scorer scorer):base(scorer.GetSimilarity()) { InitBlock(enclosingInstance); this.scorer = scorer; }
/// <summary> Creates a {@link Scorer} with the given similarity and lists of required, /// prohibited and optional scorers. In no required scorers are added, at least /// one of the optional scorers will have to match during the search. /// /// </summary> /// <param name="similarity">The similarity to be used. /// </param> /// <param name="minNrShouldMatch">The minimum number of optional added scorers that should match /// during the search. In case no required scorers are added, at least /// one of the optional scorers will have to match during the search. /// </param> /// <param name="required">the list of required scorers. /// </param> /// <param name="prohibited">the list of prohibited scorers. /// </param> /// <param name="optional">the list of optional scorers. /// </param> public BooleanScorer2(Similarity similarity, int minNrShouldMatch, System.Collections.IList required, System.Collections.IList prohibited, System.Collections.IList optional):base(similarity) { if (minNrShouldMatch < 0) { throw new System.ArgumentException("Minimum number of optional scorers should not be negative"); } coordinator = new Coordinator(this); this.minNrShouldMatch = minNrShouldMatch; optionalScorers = optional; coordinator.maxCoord += optional.Count; requiredScorers = required; coordinator.maxCoord += required.Count; prohibitedScorers = prohibited; coordinator.Init(); countingSumScorer = MakeCountingSumScorer(); }
/// <summary>Returns the score of the current document matching the query. /// Initially invalid, until {@link #Next()} is called the first time. /// </summary> /// <returns> The score of the required scorer, eventually increased by the score /// of the optional scorer when it also matches the current document. /// </returns> public override float Score() { int curDoc = reqScorer.DocID(); float reqScore = reqScorer.Score(); if (optScorer == null) { return reqScore; } int optScorerDoc = optScorer.DocID(); if (optScorerDoc < curDoc && (optScorerDoc = optScorer.Advance(curDoc)) == NO_MORE_DOCS) { optScorer = null; return reqScore; } return optScorerDoc == curDoc?reqScore + optScorer.Score():reqScore; }
/// <summary>Construct a <code>ReqOptScorer</code>.</summary> /// <param name="reqScorer">The required scorer. This must match. /// </param> /// <param name="optScorer">The optional scorer. This is used for scoring only. /// </param> public ReqOptSumScorer(Scorer reqScorer, Scorer optScorer):base(null) { // No similarity used. this.reqScorer = reqScorer; this.optScorer = optScorer; }
public override void SetScorer(Scorer scorer) { comparator.SetScorer(scorer); }
public override void SetScorer(Scorer scorer) { this.scorer = scorer; comparator.SetScorer(scorer); }
/// <summary>Returns the scorer to be used for match counting and score summing. /// Uses the given required scorer and the prohibitedScorers. /// </summary> /// <param name="requiredCountingSumScorer">A required scorer already built. /// </param> private Scorer AddProhibitedScorers(Scorer requiredCountingSumScorer) { return (prohibitedScorers.Count == 0)?requiredCountingSumScorer:new ReqExclScorer(requiredCountingSumScorer, ((prohibitedScorers.Count == 1)?(Scorer) prohibitedScorers[0]:new DisjunctionSumScorer(prohibitedScorers))); }
public override void SetScorer(Scorer scorer) { this.scorer = scorer; base.SetScorer(scorer); }
/// <summary>Creates a new instance by wrapping the given scorer. </summary> public ScoreCachingWrappingScorer(Scorer scorer) : base(scorer.GetSimilarity()) { this.scorer = scorer; }
public override Explanation Explain(IndexReader reader, int doc) { ComplexExplanation result = new ComplexExplanation(); result.SetDescription("weight(" + GetQuery() + " in " + doc + "), product of:"); Explanation idfExpl = new Explanation(idf, "idf(" + GetQuery() + ")"); // explain query weight Explanation queryExpl = new Explanation(); queryExpl.SetDescription("queryWeight(" + GetQuery() + "), product of:"); Explanation boostExpl = new Explanation(Enclosing_Instance.GetBoost(), "boost"); if (Enclosing_Instance.GetBoost() != 1.0f) { queryExpl.AddDetail(boostExpl); } queryExpl.AddDetail(idfExpl); Explanation queryNormExpl = new Explanation(queryNorm, "queryNorm"); queryExpl.AddDetail(queryNormExpl); queryExpl.SetValue(boostExpl.GetValue() * idfExpl.GetValue() * queryNormExpl.GetValue()); result.AddDetail(queryExpl); // explain field weight ComplexExplanation fieldExpl = new ComplexExplanation(); fieldExpl.SetDescription("fieldWeight(" + GetQuery() + " in " + doc + "), product of:"); Scorer scorer = Scorer(reader, true, false); if (scorer == null) { return(new Explanation(0.0f, "no matching docs")); } Explanation tfExpl = scorer.Explain(doc); fieldExpl.AddDetail(tfExpl); fieldExpl.AddDetail(idfExpl); Explanation fieldNormExpl = new Explanation(); byte[] fieldNorms = reader.Norms(Enclosing_Instance.field); float fieldNorm = fieldNorms != null?Similarity.DecodeNorm(fieldNorms[doc]) : 1.0f; fieldNormExpl.SetValue(fieldNorm); fieldNormExpl.SetDescription("fieldNorm(field=" + Enclosing_Instance.field + ", doc=" + doc + ")"); fieldExpl.AddDetail(fieldNormExpl); fieldExpl.SetMatch(tfExpl.IsMatch()); fieldExpl.SetValue(tfExpl.GetValue() * idfExpl.GetValue() * fieldNormExpl.GetValue()); result.AddDetail(fieldExpl); System.Boolean?tempAux = fieldExpl.GetMatch(); result.SetMatch(tempAux); // combine them result.SetValue(queryExpl.GetValue() * fieldExpl.GetValue()); if (queryExpl.GetValue() == 1.0f) { return(fieldExpl); } return(result); }
/// <summary>Creates a new instance by wrapping the given scorer. </summary> public ScoreCachingWrappingScorer(Scorer scorer):base(scorer.GetSimilarity()) { this.scorer = scorer; }
/* Create the scorer used to score our associated DisjunctionMaxQuery */ public override Scorer Scorer(IndexReader reader, bool scoreDocsInOrder, bool topScorer) { Scorer[] scorers = new Scorer[weights.Count]; int idx = 0; for (System.Collections.IEnumerator iter = weights.GetEnumerator(); iter.MoveNext(); ) { Weight w = (Weight) iter.Current; Scorer subScorer = w.Scorer(reader, true, false); if (subScorer != null && subScorer.NextDoc() != DocIdSetIterator.NO_MORE_DOCS) { scorers[idx++] = subScorer; } } if (idx == 0) return null; // all scorers did not have documents DisjunctionMaxScorer result = new DisjunctionMaxScorer(Enclosing_Instance.tieBreakerMultiplier, similarity, scorers, idx); return result; }
public override void SetScorer(Scorer scorer) { // score is not needed by this collector }
public SubScorer(Scorer scorer, bool required, bool prohibited, Collector collector, SubScorer next) { this.scorer = scorer; this.required = required; this.prohibited = prohibited; this.collector = collector; this.next = next; }
/// <summary>Sets the Scorer to use in case a document's score is /// needed. /// /// </summary> /// <param name="scorer">Scorer instance that you should use to /// obtain the current hit's score, if necessary. /// </param> public virtual void SetScorer(Scorer scorer) { // Empty implementation since most comparators don't need the score. This // can be overridden by those that need it. }