public abstract DocFreq ( Lucene.Net.Index.Term term ) : int | ||
term | Lucene.Net.Index.Term | |
return | int |
/// <summary> Computes a score factor for a phrase. /// /// <p/> /// The default implementation sums the idf factor for /// each term in the phrase. /// /// </summary> /// <param name="terms">the terms in the phrase /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf /// score factor for the phrase and an explanation /// for each term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation idfExplain(IList <Lucene.Net.Index.Term> terms, Searcher searcher) { if (SupportedMethods.overridesCollectionIDF) { float idf = Idf(terms, searcher); return(new IDFExplanation { GetIdf = () => idf, Explain = () => "Inexplicable" }); } int max = searcher.MaxDoc(); float idf2 = 0.0f; System.Text.StringBuilder exp = new System.Text.StringBuilder(); foreach (Term term in terms) { int df = searcher.DocFreq(term); idf2 += Idf(df, max); exp.Append(" "); exp.Append(term.Text()); exp.Append("="); exp.Append(df); } float fIdf = idf2; return(new IDFExplanation { GetIdf = () => fIdf, Explain = () => exp.ToString() }); }
/// <summary> Computes a score factor for a simple term and returns an explanation /// for that score factor. /// /// <p/> /// The default implementation uses: /// /// <code> /// idf(searcher.docFreq(term), searcher.MaxDoc); /// </code> /// /// Note that <see cref="Searcher.MaxDoc" /> is used instead of /// <see cref="Lucene.Net.Index.IndexReader.NumDocs()" /> because it is /// proportional to <see cref="Searcher.DocFreq(Term)" /> , i.e., when one is /// inaccurate, so is the other, and in the same direction. /// /// </summary> /// <param name="term">the term in question /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf score factor /// and an explanation for the term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation IdfExplain(Term term, Searcher searcher) { int df = searcher.DocFreq(term); int max = searcher.MaxDoc; float idf2 = Idf(df, max); return(new AnonymousClassIDFExplanation1(df, max, idf2, this)); }
/// <summary> Computes a score factor for a simple term and returns an explanation /// for that score factor. /// /// <p/> /// The default implementation uses: /// /// <pre> /// idf(searcher.docFreq(term), searcher.maxDoc()); /// </pre> /// /// Note that {@link Searcher#MaxDoc()} is used instead of /// {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is /// proportional to {@link Searcher#DocFreq(Term)} , i.e., when one is /// inaccurate, so is the other, and in the same direction. /// /// </summary> /// <param name="term">the term in question /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf score factor /// and an explanation for the term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation IdfExplain(Term term, Searcher searcher) { if (SupportedMethods.overridesTermIDF) { float idf = Idf(term, searcher); return(new AnonymousClassIDFExplanation(idf, this)); } int df = searcher.DocFreq(term); int max = searcher.MaxDoc(); float idf2 = Idf(df, max); return(new AnonymousClassIDFExplanation1(df, max, idf2, this)); }
public MultiPhraseWeight(MultiPhraseQuery enclosingInstance, Searcher searcher) { InitBlock(enclosingInstance); this.similarity = Enclosing_Instance.GetSimilarity(searcher); // compute idf int maxDoc = searcher.MaxDoc; foreach (Term[] terms in enclosingInstance.termArrays) { foreach (Term term in terms) { idf += similarity.Idf(searcher.DocFreq(term), maxDoc); } } }
/// <summary> Computes a score factor for a phrase. /// /// <p/> /// The default implementation sums the idf factor for /// each term in the phrase. /// /// </summary> /// <param name="terms">the terms in the phrase /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf /// score factor for the phrase and an explanation /// for each term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation IdfExplain(ICollection <Term> terms, Searcher searcher) { int max = searcher.MaxDoc; float idf2 = 0.0f; System.Text.StringBuilder exp = new System.Text.StringBuilder(); foreach (Term term in terms) { int df = searcher.DocFreq(term); idf2 += Idf(df, max); exp.Append(" "); exp.Append(term.Text); exp.Append("="); exp.Append(df); } float fIdf = idf2; return(new AnonymousClassIDFExplanation3(fIdf, exp, this)); }
/// <summary> Computes a score factor for a simple term and returns an explanation /// for that score factor. /// /// <p/> /// The default implementation uses: /// /// <pre> /// idf(searcher.docFreq(term), searcher.maxDoc()); /// </pre> /// /// Info: <see cref="Searcher.MaxDoc()"/> is used instead of /// <see cref="Lucene.Net.Index.IndexReader.NumDocs()"/> because it is /// proportional to <see cref="Searcher.DocFreq(Term)"/> , i.e., when one is /// inaccurate, so is the other, and in the same direction. /// /// </summary> /// <param name="term">the term in question /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf score factor /// and an explanation for the term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation IdfExplain(Term term, Searcher searcher) { if (SupportedMethods.overridesTermIDF) { float idf = Idf(term, searcher); return(new IDFExplanation { GetIdf = () => idf, Explain = () => "Inexplicable" }); } int df = searcher.DocFreq(term); int max = searcher.MaxDoc(); float idf2 = Idf(df, max); return(new IDFExplanation { GetIdf = () => idf2, Explain = () => "idf(docFreq=" + df + ", maxDocs=" + max + ")" }); }
/// <summary> Computes a score factor for a phrase. /// /// <p/> /// The default implementation sums the idf factor for /// each term in the phrase. /// /// </summary> /// <param name="terms">the terms in the phrase /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf /// score factor for the phrase and an explanation /// for each term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation idfExplain(System.Collections.ICollection terms, Searcher searcher) { if (SupportedMethods.overridesCollectionIDF) { float idf = Idf(terms, searcher); return(new AnonymousClassIDFExplanation2(idf, this)); } int max = searcher.MaxDoc(); float idf2 = 0.0f; System.Text.StringBuilder exp = new System.Text.StringBuilder(); foreach (Term term in terms) { int df = searcher.DocFreq(term); idf2 += Idf(df, max); exp.Append(" "); exp.Append(term.Text()); exp.Append("="); exp.Append(df); } float fIdf = idf2; return(new AnonymousClassIDFExplanation3(fIdf, exp, this)); }
/// <summary> Computes a score factor for a phrase. /// /// <p/> /// The default implementation sums the idf factor for /// each term in the phrase. /// /// </summary> /// <param name="terms">the terms in the phrase /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf /// score factor for the phrase and an explanation /// for each term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation idfExplain(System.Collections.ICollection terms, Searcher searcher) { if (SupportedMethods.overridesCollectionIDF) { float idf = Idf(terms, searcher); return new AnonymousClassIDFExplanation2(idf, this); } int max = searcher.MaxDoc(); float idf2 = 0.0f; System.Text.StringBuilder exp = new System.Text.StringBuilder(); foreach (Term term in terms) { int df = searcher.DocFreq(term); idf2 += Idf(df, max); exp.Append(" "); exp.Append(term.Text()); exp.Append("="); exp.Append(df); } float fIdf = idf2; return new AnonymousClassIDFExplanation3(fIdf, exp, this); }
/// <summary> Computes a score factor for a simple term and returns an explanation /// for that score factor. /// /// <p/> /// The default implementation uses: /// /// <pre> /// idf(searcher.docFreq(term), searcher.maxDoc()); /// </pre> /// /// Note that {@link Searcher#MaxDoc()} is used instead of /// {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is /// proportional to {@link Searcher#DocFreq(Term)} , i.e., when one is /// inaccurate, so is the other, and in the same direction. /// /// </summary> /// <param name="term">the term in question /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf score factor /// and an explanation for the term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation IdfExplain(Term term, Searcher searcher) { if (SupportedMethods.overridesTermIDF) { float idf = Idf(term, searcher); return new AnonymousClassIDFExplanation(idf, this); } int df = searcher.DocFreq(term); int max = searcher.MaxDoc(); float idf2 = Idf(df, max); return new AnonymousClassIDFExplanation1(df, max, idf2, this); }
public virtual float Idf(Term term, Searcher searcher) { return Idf(searcher.DocFreq(term), searcher.MaxDoc()); }
/// <summary> Computes a score factor for a phrase. /// /// <p/> /// The default implementation sums the idf factor for /// each term in the phrase. /// /// </summary> /// <param name="terms">the terms in the phrase /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf /// score factor for the phrase and an explanation /// for each term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation idfExplain(IList<Lucene.Net.Index.Term> terms, Searcher searcher) { if (SupportedMethods.overridesCollectionIDF) { float idf = Idf(terms, searcher); return new IDFExplanation { GetIdf = () => idf, Explain = () => "Inexplicable" }; } int max = searcher.MaxDoc(); float idf2 = 0.0f; System.Text.StringBuilder exp = new System.Text.StringBuilder(); foreach (Term term in terms) { int df = searcher.DocFreq(term); idf2 += Idf(df, max); exp.Append(" "); exp.Append(term.Text()); exp.Append("="); exp.Append(df); } float fIdf = idf2; return new IDFExplanation { GetIdf = () => fIdf, Explain = () => exp.ToString() }; }
/// <summary> Computes a score factor for a simple term and returns an explanation /// for that score factor. /// /// <p/> /// The default implementation uses: /// /// <pre> /// idf(searcher.docFreq(term), searcher.maxDoc()); /// </pre> /// /// Info: <see cref="Searcher.MaxDoc()"/> is used instead of /// <see cref="Lucene.Net.Index.IndexReader.NumDocs()"/> because it is /// proportional to <see cref="Searcher.DocFreq(Term)"/> , i.e., when one is /// inaccurate, so is the other, and in the same direction. /// /// </summary> /// <param name="term">the term in question /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf score factor /// and an explanation for the term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation IdfExplain(Term term, Searcher searcher) { if (SupportedMethods.overridesTermIDF) { float idf = Idf(term, searcher); return new IDFExplanation { GetIdf = () => idf, Explain = () => "Inexplicable" }; } int df = searcher.DocFreq(term); int max = searcher.MaxDoc(); float idf2 = Idf(df, max); return new IDFExplanation { GetIdf = () => idf2, Explain = () => "idf(docFreq=" + df + ", maxDocs=" + max + ")" }; }
/// <summary> Computes a score factor for a phrase. /// /// <p/> /// The default implementation sums the idf factor for /// each term in the phrase. /// /// </summary> /// <param name="terms">the terms in the phrase /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf /// score factor for the phrase and an explanation /// for each term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation IdfExplain(ICollection<Term> terms, Searcher searcher) { int max = searcher.MaxDoc; float idf2 = 0.0f; System.Text.StringBuilder exp = new System.Text.StringBuilder(); foreach (Term term in terms) { int df = searcher.DocFreq(term); idf2 += Idf(df, max); exp.Append(" "); exp.Append(term.Text); exp.Append("="); exp.Append(df); } float fIdf = idf2; return new AnonymousClassIDFExplanation3(fIdf, exp, this); }
/// <summary> Computes a score factor for a simple term and returns an explanation /// for that score factor. /// /// <p/> /// The default implementation uses: /// /// <code> /// idf(searcher.docFreq(term), searcher.MaxDoc); /// </code> /// /// Note that <see cref="Searcher.MaxDoc" /> is used instead of /// <see cref="Lucene.Net.Index.IndexReader.NumDocs()" /> because it is /// proportional to <see cref="Searcher.DocFreq(Term)" /> , i.e., when one is /// inaccurate, so is the other, and in the same direction. /// /// </summary> /// <param name="term">the term in question /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> an IDFExplain object that includes both an idf score factor /// and an explanation for the term. /// </returns> /// <throws> IOException </throws> public virtual IDFExplanation IdfExplain(Term term, Searcher searcher) { int df = searcher.DocFreq(term); int max = searcher.MaxDoc; float idf2 = Idf(df, max); return new AnonymousClassIDFExplanation1(df, max, idf2, this); }
/// <summary>Computes a score factor for a simple term. /// /// <p>The default implementation is:<pre> /// return idf(searcher.docFreq(term), searcher.maxDoc()); /// </pre> /// /// Note that {@link Searcher#MaxDoc()} is used instead of /// {@link IndexReader#NumDocs()} because it is proportional to /// {@link Searcher#DocFreq(Term)} , i.e., when one is inaccurate, /// so is the other, and in the same direction. /// /// </summary> /// <param name="term">the term in question /// </param> /// <param name="searcher">the document collection being searched /// </param> /// <returns> a score factor for the term /// </returns> public virtual float Idf(Term term, Searcher searcher) { return(Ldf(searcher.DocFreq(term), searcher.MaxDoc())); }
public MultiPhraseWeight(MultiPhraseQuery enclosingInstance, Searcher searcher) { InitBlock(enclosingInstance); this.similarity = Enclosing_Instance.GetSimilarity(searcher); // compute idf int maxDoc = searcher.MaxDoc; foreach (Term[] terms in enclosingInstance.termArrays) { foreach (Term term in terms) { idf += similarity.Idf(searcher.DocFreq(term), maxDoc); } } }