public virtual void Collect(int doc) { float score = scorer.GetScore(); try { long startMS = J2N.Time.NanoTime() / J2N.Time.MillisecondsPerNanosecond; // LUCENENET: Use NanoTime() rather than CurrentTimeMilliseconds() for more accurate/reliable results for (int i = lastDoc[0] + 1; i <= doc; i++) { Weight w = s.CreateNormalizedWeight(q); Scorer scorer_ = w.GetScorer(context[leafPtr], liveDocs); Assert.IsTrue(scorer_.Advance(i) != DocIdSetIterator.NO_MORE_DOCS, "query collected " + doc + " but skipTo(" + i + ") says no more docs!"); Assert.AreEqual(doc, scorer_.DocID, "query collected " + doc + " but skipTo(" + i + ") got to " + scorer_.DocID); float skipToScore = scorer_.GetScore(); Assert.AreEqual(skipToScore, scorer_.GetScore(), maxDiff, "unstable skipTo(" + i + ") score!"); Assert.AreEqual(score, skipToScore, maxDiff, "query assigned doc " + doc + " a score of <" + score + "> but skipTo(" + i + ") has <" + skipToScore + ">!"); // Hurry things along if they are going slow (eg // if you got SimpleText codec this will kick in): if (i < doc && (J2N.Time.NanoTime() / J2N.Time.MillisecondsPerNanosecond) - startMS > 5) // LUCENENET: Use NanoTime() rather than CurrentTimeMilliseconds() for more accurate/reliable results { i = doc - 1; } } lastDoc[0] = doc; } catch (Exception e) when(e.IsIOException()) { throw RuntimeException.Create(e); } }
public virtual void Collect(int doc) { float score = scorer.GetScore(); try { long startMS = Environment.TickCount; for (int i = lastDoc[0] + 1; i <= doc; i++) { Weight w = s.CreateNormalizedWeight(q); Scorer scorer_ = w.GetScorer(context[leafPtr], liveDocs); Assert.IsTrue(scorer_.Advance(i) != DocIdSetIterator.NO_MORE_DOCS, "query collected " + doc + " but skipTo(" + i + ") says no more docs!"); Assert.AreEqual(doc, scorer_.DocID, "query collected " + doc + " but skipTo(" + i + ") got to " + scorer_.DocID); float skipToScore = scorer_.GetScore(); Assert.AreEqual(skipToScore, scorer_.GetScore(), maxDiff, "unstable skipTo(" + i + ") score!"); Assert.AreEqual(score, skipToScore, maxDiff, "query assigned doc " + doc + " a score of <" + score + "> but skipTo(" + i + ") has <" + skipToScore + ">!"); // Hurry things along if they are going slow (eg // if you got SimpleText codec this will kick in): if (i < doc && Environment.TickCount - startMS > 5) { i = doc - 1; } } lastDoc[0] = doc; } catch (IOException e) { throw new Exception(e.ToString(), e); } }
public override void Collect(int doc) { if (m_curDocs == null) { // Cache was too large cachedScorer.score = scorer.GetScore(); cachedScorer.doc = doc; m_other.Collect(doc); return; } // Allocate a bigger array or abort caching if (m_upto == m_curDocs.Length) { m_base += m_upto; // Compute next array length - don't allocate too big arrays int nextLength = 8 * m_curDocs.Length; if (nextLength > MAX_ARRAY_SIZE) { nextLength = MAX_ARRAY_SIZE; } if (m_base + nextLength > m_maxDocsToCache) { // try to allocate a smaller array nextLength = m_maxDocsToCache - m_base; if (nextLength <= 0) { // Too many docs to collect -- clear cache m_curDocs = null; curScores = null; m_cachedSegs.Clear(); m_cachedDocs.Clear(); cachedScores.Clear(); cachedScorer.score = scorer.GetScore(); cachedScorer.doc = doc; m_other.Collect(doc); return; } } m_curDocs = new int[nextLength]; m_cachedDocs.Add(m_curDocs); curScores = new float[nextLength]; cachedScores.Add(curScores); m_upto = 0; } m_curDocs[m_upto] = doc; cachedScorer.score = curScores[m_upto] = scorer.GetScore(); m_upto++; cachedScorer.doc = doc; m_other.Collect(doc); }
public void Collect(int doc) { // just a sanity check to avoid IOOB. if (idx == mscores.Length) { return; } // just call score() a couple of times and record the score. mscores[idx] = scorer.GetScore(); mscores[idx] = scorer.GetScore(); mscores[idx] = scorer.GetScore(); ++idx; }
public void Collect(int doc) { // just a sanity check to avoid IOOB. if (Idx == Mscores.Length) { return; } // just call score() a couple of times and record the score. Mscores[Idx] = Scorer_Renamed.GetScore(); Mscores[Idx] = Scorer_Renamed.GetScore(); Mscores[Idx] = Scorer_Renamed.GetScore(); ++Idx; }
public virtual void Collect(int doc) { if (scorer.GetScore() > 0) { c.Collect(doc); } }
public override float GetScore() { coordinator.nrMatchers = 0; float sum = countingSumScorer.GetScore(); return(sum * coordinator.coordFactors[coordinator.nrMatchers]); }
public virtual void TestNext() { Term allTerm = new Term(FIELD, "all"); TermQuery termQuery = new TermQuery(allTerm); Weight weight = IndexSearcher.CreateNormalizedWeight(termQuery); Assert.IsTrue(IndexSearcher.TopReaderContext is AtomicReaderContext); AtomicReaderContext context = (AtomicReaderContext)IndexSearcher.TopReaderContext; Scorer ts = weight.GetScorer(context, (context.AtomicReader).LiveDocs); Assert.IsTrue(ts.NextDoc() != DocIdSetIterator.NO_MORE_DOCS, "next did not return a doc"); Assert.IsTrue(ts.GetScore() == 1.6931472f, "score is not correct"); Assert.IsTrue(ts.NextDoc() != DocIdSetIterator.NO_MORE_DOCS, "next did not return a doc"); Assert.IsTrue(ts.GetScore() == 1.6931472f, "score is not correct"); Assert.IsTrue(ts.NextDoc() == DocIdSetIterator.NO_MORE_DOCS, "next returned a doc and it should not have"); }
public virtual void Collect(int doc) { float score = scorer.GetScore(); doc = doc + @base; Docs.Add(new TestHit(OuterInstance, doc, score)); Assert.IsTrue(score > 0, "score " + score + " is not greater than 0"); Assert.IsTrue(doc == 0 || doc == 5, "Doc: " + doc + " does not equal 0 or doc does not equal 5"); }
public override float GetScore() { Debug.Assert(Iterating()); float score = @in.GetScore(); Debug.Assert(!float.IsNaN(score)); Debug.Assert(!float.IsNaN(score)); return(score); }
public override float GetScore() { int doc = scorer.DocID; if (doc != curDoc) { curScore = scorer.GetScore(); curDoc = doc; } return(curScore); }
protected override void AfterNext() { Scorer sub = m_subScorers[0]; m_doc = sub.DocID; if (m_doc != NO_MORE_DOCS) { m_score = sub.GetScore(); m_nrMatchers = 1; CountMatches(1); CountMatches(2); } }
public virtual void Collect(int doc) { float score = sc.GetScore(); lastDoc[0] = doc; try { if (scorer == null) { Weight w = s.CreateNormalizedWeight(q); AtomicReaderContext context = readerContextArray[leafPtr]; scorer = w.GetScorer(context, (context.AtomicReader).LiveDocs); } int op = order[(opidx[0]++) % order.Length]; // System.out.println(op==skip_op ? // "skip("+(sdoc[0]+1)+")":"next()"); bool more = op == skip_op?scorer.Advance(scorer.DocID + 1) != DocIdSetIterator.NO_MORE_DOCS : scorer.NextDoc() != DocIdSetIterator.NO_MORE_DOCS; int scorerDoc = scorer.DocID; float scorerScore = scorer.GetScore(); float scorerScore2 = scorer.GetScore(); float scoreDiff = Math.Abs(score - scorerScore); float scorerDiff = Math.Abs(scorerScore2 - scorerScore); if (!more || doc != scorerDoc || scoreDiff > maxDiff || scorerDiff > maxDiff) { StringBuilder sbord = new StringBuilder(); for (int i = 0; i < order.Length; i++) { sbord.Append(order[i] == skip_op ? " skip()" : " next()"); } throw new Exception("ERROR matching docs:" + "\n\t" + (doc != scorerDoc ? "--> " : "") + "doc=" + doc + ", scorerDoc=" + scorerDoc + "\n\t" + (!more ? "--> " : "") + "tscorer.more=" + more + "\n\t" + (scoreDiff > maxDiff ? "--> " : "") + "scorerScore=" + scorerScore + " scoreDiff=" + scoreDiff + " maxDiff=" + maxDiff + "\n\t" + (scorerDiff > maxDiff ? "--> " : "") + "scorerScore2=" + scorerScore2 + " scorerDiff=" + scorerDiff + "\n\thitCollector.Doc=" + doc + " score=" + score + "\n\t Scorer=" + scorer + "\n\t Query=" + q + " " + q.GetType().Name + "\n\t Searcher=" + s + "\n\t Order=" + sbord + "\n\t Op=" + (op == skip_op ? " skip()" : " next()")); } } catch (IOException e) { throw new Exception(e.ToString(), e); } }
public void Collect(int doc) { BucketTable table = bucketTable; int i = doc & BucketTable.MASK; Bucket bucket = table.buckets[i]; if (bucket.Doc != doc) // invalid bucket { bucket.Doc = doc; // set doc bucket.Score = scorer.GetScore(); // initialize score bucket.Bits = mask; // initialize mask bucket.Coord = 1; // initialize coord bucket.Next = table.first; // push onto valid list table.first = bucket; } // valid bucket else { bucket.Score += scorer.GetScore(); // increment score bucket.Bits |= mask; // add bits in mask bucket.Coord++; // increment coord } }
public override float GetScore() { int doc = DocID; if (doc >= lastScoredDoc) { if (doc > lastScoredDoc) { lastDocScore = scorer.GetScore(); lastScoredDoc = doc; } outerInstance.coordinator.nrMatchers++; } return(lastDocScore); }
public void Collect(int doc) { DocIDs[Buffered] = doc; Scores[Buffered] = Scorer_Renamed.GetScore(); try { Freqs[Buffered] = Scorer_Renamed.Freq; } catch (System.NotSupportedException) { Freqs[Buffered] = -1; } if (++Buffered == BufferSize) { Flush(); } }
public void Collect(int doc) { docIDs[buffered] = doc; scores[buffered] = scorer.GetScore(); try { freqs[buffered] = scorer.Freq; } catch (NotSupportedException) { freqs[buffered] = -1; } if (++buffered == bufferSize) { Flush(); } }
public void Collect(int doc) { docIDs[buffered] = doc; scores[buffered] = scorer.GetScore(); try { freqs[buffered] = scorer.Freq; } catch (Exception e) when(e.IsUnsupportedOperationException()) { freqs[buffered] = -1; } if (++buffered == bufferSize) { Flush(); } }
private void AssertNext(Scorer expected, Scorer actual) { if (actual == null) { Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, expected.NextDoc()); return; } int doc; while ((doc = expected.NextDoc()) != DocIdSetIterator.NO_MORE_DOCS) { Assert.AreEqual(doc, actual.NextDoc()); Assert.AreEqual(expected.Freq, actual.Freq); float expectedScore = expected.GetScore(); float actualScore = actual.GetScore(); Assert.AreEqual(expectedScore, actualScore, CheckHits.ExplainToleranceDelta(expectedScore, actualScore)); } Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, actual.NextDoc()); }
public virtual void Collect(int doc) { Explanation exp = null; doc = doc + @base; try { exp = s.Explain(q, doc); } catch (IOException e) { throw new Exception("exception in hitcollector of [[" + d + "]] for #" + doc, e); } Assert.IsNotNull(exp, "Explanation of [[" + d + "]] for #" + doc + " is null"); CheckHits.VerifyExplanation(d, doc, scorer.GetScore(), deep, exp); Assert.IsTrue(exp.IsMatch, "Explanation of [[" + d + "]] for #" + doc + " does not indicate match: " + exp.ToString()); }
public virtual void Collect(int doc) { Explanation exp; // LUCENENET: IDE0059: Remove unnecessary value assignment doc = doc + @base; try { exp = s.Explain(q, doc); } catch (Exception e) when(e.IsIOException()) { throw RuntimeException.Create("exception in hitcollector of [[" + d + "]] for #" + doc, e); } Assert.IsNotNull(exp, "Explanation of [[" + d + "]] for #" + doc + " is null"); CheckHits.VerifyExplanation(d, doc, scorer.GetScore(), deep, exp); Assert.IsTrue(exp.IsMatch, "Explanation of [[" + d + "]] for #" + doc + " does not indicate match: " + exp.ToString()); }
private void AssertAdvance(Scorer expected, Scorer actual, int amount) { if (actual is null) { Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, expected.NextDoc()); return; } int prevDoc = 0; int doc; while ((doc = expected.Advance(prevDoc + amount)) != DocIdSetIterator.NO_MORE_DOCS) { Assert.AreEqual(doc, actual.Advance(prevDoc + amount)); Assert.AreEqual(expected.Freq, actual.Freq); float expectedScore = expected.GetScore(); float actualScore = actual.GetScore(); Assert.AreEqual(expectedScore, actualScore, CheckHits.ExplainToleranceDelta(expectedScore, actualScore)); prevDoc = doc; } Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, actual.Advance(prevDoc + amount)); }
/// <summary> /// Returns the score of the current document matching the query. /// Initially invalid, until <see cref="NextDoc()"/> 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 GetScore() { // TODO: sum into a double and cast to float if we ever send required clauses to BS1 int curDoc = reqScorer.DocID; float reqScore = reqScorer.GetScore(); if (optScorer is 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.GetScore() : reqScore); }
public override sealed float GetScore() { return(scorer.GetScore()); }
public virtual void Collect(int doc) { Assert.IsFalse(float.IsInfinity(scorer.Freq)); Assert.IsFalse(float.IsInfinity(scorer.GetScore())); }
public virtual void Collect(int doc) { //System.out.println("Doc=" + doc + " score=" + score); Assert.AreEqual(2.0f, scorer.GetScore(), 0); }
public virtual void Collect(int doc) { Assert.AreEqual(1.0f, scorer.GetScore(), 0); }
public virtual void Collect(int doc) { scores[doc + @base] = scorer.GetScore(); }
[AwaitsFix(BugUrl = "https://github.com/apache/lucenenet/issues/269")] // LUCENENET TODO: this test fails on x86 on .NET Framework in Release mode only #endif public virtual void TestBS2DisjunctionNextVsAdvance() { Directory d = NewDirectory(); RandomIndexWriter w = new RandomIndexWriter( #if FEATURE_INSTANCE_TESTDATA_INITIALIZATION this, #endif Random, d); int numDocs = AtLeast(300); for (int docUpto = 0; docUpto < numDocs; docUpto++) { string contents = "a"; if (Random.Next(20) <= 16) { contents += " b"; } if (Random.Next(20) <= 8) { contents += " c"; } if (Random.Next(20) <= 4) { contents += " d"; } if (Random.Next(20) <= 2) { contents += " e"; } if (Random.Next(20) <= 1) { contents += " f"; } Document doc = new Document(); doc.Add(new TextField("field", contents, Field.Store.NO)); w.AddDocument(doc); } w.ForceMerge(1); IndexReader r = w.GetReader(); IndexSearcher s = NewSearcher(r); w.Dispose(); for (int iter = 0; iter < 10 * RandomMultiplier; iter++) { if (Verbose) { Console.WriteLine("iter=" + iter); } IList <string> terms = new List <string> { "a", "b", "c", "d", "e", "f" }; int numTerms = TestUtil.NextInt32(Random, 1, terms.Count); while (terms.Count > numTerms) { terms.RemoveAt(Random.Next(terms.Count)); } if (Verbose) { Console.WriteLine(" terms=" + terms); } BooleanQuery q = new BooleanQuery(); foreach (string term in terms) { q.Add(new BooleanClause(new TermQuery(new Term("field", term)), Occur.SHOULD)); } Weight weight = s.CreateNormalizedWeight(q); Scorer scorer = weight.GetScorer(s.m_leafContexts[0], null); // First pass: just use .NextDoc() to gather all hits IList <ScoreDoc> hits = new List <ScoreDoc>(); while (scorer.NextDoc() != DocIdSetIterator.NO_MORE_DOCS) { hits.Add(new ScoreDoc(scorer.DocID, scorer.GetScore())); } if (Verbose) { Console.WriteLine(" " + hits.Count + " hits"); } // Now, randomly next/advance through the list and // verify exact match: for (int iter2 = 0; iter2 < 10; iter2++) { weight = s.CreateNormalizedWeight(q); scorer = weight.GetScorer(s.m_leafContexts[0], null); if (Verbose) { Console.WriteLine(" iter2=" + iter2); } int upto = -1; while (upto < hits.Count) { int nextUpto; int nextDoc; int left = hits.Count - upto; if (left == 1 || Random.nextBoolean()) { // next nextUpto = 1 + upto; nextDoc = scorer.NextDoc(); } else { // advance int inc = TestUtil.NextInt32(Random, 1, left - 1); nextUpto = inc + upto; nextDoc = scorer.Advance(hits[nextUpto].Doc); } if (nextUpto == hits.Count) { Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, nextDoc); } else { ScoreDoc hit = hits[nextUpto]; Assert.AreEqual(hit.Doc, nextDoc); // Test for precise float equality: Assert.IsTrue(hit.Score == scorer.GetScore(), "doc " + hit.Doc + " has wrong score: expected=" + hit.Score + " actual=" + scorer.GetScore()); } upto = nextUpto; } } } r.Dispose(); d.Dispose(); }
public virtual void Collect(int doc) { Assert.AreEqual(1.0f, scorer.GetScore(), SCORE_COMP_THRESH, "score for doc " + (doc + @base) + " was not correct"); }