Lucene.Net.Search.Similarities: Fixed up documentation comments
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/2a1541c1 Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/2a1541c1 Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/2a1541c1 Branch: refs/heads/master Commit: 2a1541c184dd66a4d710c1f15590f27c9f5e7c53 Parents: 1197b1a Author: Shad Storhaug <[email protected]> Authored: Fri Jun 2 23:43:49 2017 +0700 Committer: Shad Storhaug <[email protected]> Committed: Fri Jun 2 23:43:49 2017 +0700 ---------------------------------------------------------------------- CONTRIBUTING.md | 2 +- src/Lucene.Net/Lucene.Net.csproj | 1 - .../Search/Similarities/AfterEffect.cs | 9 +- .../Search/Similarities/AfterEffectB.cs | 1 + .../Search/Similarities/AfterEffectL.cs | 1 + .../Search/Similarities/BM25Similarity.cs | 67 +- .../Search/Similarities/BasicModel.cs | 11 +- .../Search/Similarities/BasicModelBE.cs | 14 +- .../Search/Similarities/BasicModelD.cs | 9 +- .../Search/Similarities/BasicModelG.cs | 5 +- .../Search/Similarities/BasicModelIF.cs | 1 + .../Search/Similarities/BasicModelIn.cs | 1 + .../Search/Similarities/BasicModelIne.cs | 1 + .../Search/Similarities/BasicModelP.cs | 5 +- .../Search/Similarities/BasicStats.cs | 17 +- .../Search/Similarities/DFRSimilarity.cs | 105 +-- .../Search/Similarities/DefaultSimilarity.cs | 69 +- .../Search/Similarities/Distribution.cs | 10 +- .../Search/Similarities/DistributionLL.cs | 4 +- .../Search/Similarities/DistributionSPL.cs | 4 +- .../Search/Similarities/IBSimilarity.cs | 107 +-- .../Similarities/LMDirichletSimilarity.cs | 18 +- .../Similarities/LMJelinekMercerSimilarity.cs | 12 +- .../Search/Similarities/LMSimilarity.cs | 38 +- src/Lucene.Net/Search/Similarities/Lambda.cs | 10 +- src/Lucene.Net/Search/Similarities/LambdaDF.cs | 3 +- src/Lucene.Net/Search/Similarities/LambdaTTF.cs | 3 +- .../Search/Similarities/MultiSimilarity.cs | 5 +- .../Search/Similarities/Normalization.cs | 13 +- .../Search/Similarities/NormalizationH1.cs | 16 +- .../Search/Similarities/NormalizationH2.cs | 14 +- .../Search/Similarities/NormalizationH3.cs | 11 +- .../Search/Similarities/NormalizationZ.cs | 11 +- .../Similarities/PerFieldSimilarityWrapper.cs | 12 +- .../Search/Similarities/Similarity.cs | 139 ++-- .../Search/Similarities/SimilarityBase.cs | 63 +- .../Search/Similarities/TFIDFSimilarity.cs | 680 +++++++++---------- 37 files changed, 762 insertions(+), 730 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/CONTRIBUTING.md ---------------------------------------------------------------------- diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index c54ac21..68b0f1c 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -52,7 +52,7 @@ helpers to help with that, see for examples see our [Java style methods to avoid 1. Lucene.Net.Core (project) 1. Codecs (namespace) - 2. Search (namespace) (Except for Search.Payloads) + 2. Search (namespace) (Except for Search.Payloads and Search.Similarities) 3. Support (namespace) 4. Util (namespace) (Except for Util.Fst) 2. Lucene.Net.Codecs (project) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Lucene.Net.csproj ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Lucene.Net.csproj b/src/Lucene.Net/Lucene.Net.csproj index 0dd30df..eb166ac 100644 --- a/src/Lucene.Net/Lucene.Net.csproj +++ b/src/Lucene.Net/Lucene.Net.csproj @@ -42,7 +42,6 @@ <WarningLevel>4</WarningLevel> <PlatformTarget>AnyCPU</PlatformTarget> <Prefer32Bit>false</Prefer32Bit> - <DocumentationFile>bin\Debug\Lucene.Net.XML</DocumentationFile> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> <DebugType>pdbonly</DebugType> http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/AfterEffect.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/AfterEffect.cs b/src/Lucene.Net/Search/Similarities/AfterEffect.cs index 0e9515d..560da03 100644 --- a/src/Lucene.Net/Search/Similarities/AfterEffect.cs +++ b/src/Lucene.Net/Search/Similarities/AfterEffect.cs @@ -20,14 +20,15 @@ namespace Lucene.Net.Search.Similarities */ /// <summary> - /// this class acts as the base class for the implementations of the <em>first - /// normalization of the informative content</em> in the DFR framework. this + /// This class acts as the base class for the implementations of the <em>first + /// normalization of the informative content</em> in the DFR framework. This /// component is also called the <em>after effect</em> and is defined by the /// formula <em>Inf<sub>2</sub> = 1 - Prob<sub>2</sub></em>, where /// <em>Prob<sub>2</sub></em> measures the <em>information gain</em>. + /// <para/> + /// @lucene.experimental /// </summary> - /// <seealso cref= DFRSimilarity - /// @lucene.experimental </seealso> + /// <seealso cref="DFRSimilarity"/> #if FEATURE_SERIALIZABLE [Serializable] #endif http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/AfterEffectB.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/AfterEffectB.cs b/src/Lucene.Net/Search/Similarities/AfterEffectB.cs index ef355c3..e50aa01 100644 --- a/src/Lucene.Net/Search/Similarities/AfterEffectB.cs +++ b/src/Lucene.Net/Search/Similarities/AfterEffectB.cs @@ -21,6 +21,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Model of the information gain based on the ratio of two Bernoulli processes. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/AfterEffectL.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/AfterEffectL.cs b/src/Lucene.Net/Search/Similarities/AfterEffectL.cs index 023c366..80244b8 100644 --- a/src/Lucene.Net/Search/Similarities/AfterEffectL.cs +++ b/src/Lucene.Net/Search/Similarities/AfterEffectL.cs @@ -21,6 +21,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Model of the information gain based on Laplace's law of succession. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BM25Similarity.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BM25Similarity.cs b/src/Lucene.Net/Search/Similarities/BM25Similarity.cs index a7a992d..8f920e0 100644 --- a/src/Lucene.Net/Search/Similarities/BM25Similarity.cs +++ b/src/Lucene.Net/Search/Similarities/BM25Similarity.cs @@ -30,6 +30,7 @@ namespace Lucene.Net.Search.Similarities /// Susan Jones, Micheline Hancock-Beaulieu, and Mike Gatford. Okapi at TREC-3. /// In Proceedings of the Third <b>T</b>ext <b>RE</b>trieval <b>C</b>onference (TREC 1994). /// Gaithersburg, USA, November 1994. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -53,10 +54,10 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// BM25 with these default values: - /// <ul> - /// <li>{@code k1 = 1.2}, - /// <li>{@code b = 0.75}.</li> - /// </ul> + /// <list type="bullet"> + /// <item><description><c>k1 = 1.2</c>,</description></item> + /// <item><description><c>b = 0.75</c>.</description></item> + /// </list> /// </summary> public BM25Similarity() { @@ -65,29 +66,29 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Implemented as <code>log(1 + (numDocs - docFreq + 0.5)/(docFreq + 0.5))</code>. </summary> + /// Implemented as <c>log(1 + (numDocs - docFreq + 0.5)/(docFreq + 0.5))</c>. </summary> protected internal virtual float Idf(long docFreq, long numDocs) { return (float)Math.Log(1 + (numDocs - docFreq + 0.5D) / (docFreq + 0.5D)); } /// <summary> - /// Implemented as <code>1 / (distance + 1)</code>. </summary> + /// Implemented as <c>1 / (distance + 1)</c>. </summary> protected internal virtual float SloppyFreq(int distance) { return 1.0f / (distance + 1); } /// <summary> - /// The default implementation returns <code>1</code> </summary> + /// The default implementation returns <c>1</c> </summary> protected internal virtual float ScorePayload(int doc, int start, int end, BytesRef payload) { return 1; } /// <summary> - /// The default implementation computes the average as <code>sumTotalTermFreq / maxDoc</code>, - /// or returns <code>1</code> if the index does not store sumTotalTermFreq (Lucene 3.x indexes + /// The default implementation computes the average as <c>sumTotalTermFreq / maxDoc</c>, + /// or returns <c>1</c> if the index does not store sumTotalTermFreq (Lucene 3.x indexes /// or any field that omits frequency information). /// </summary> protected internal virtual float AvgFieldLength(CollectionStatistics collectionStats) @@ -104,10 +105,10 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// The default implementation encodes <code>boost / sqrt(length)</code> - /// with <seealso cref="SmallSingle#floatToByte315(float)"/>. this is compatible with + /// The default implementation encodes <c>boost / sqrt(length)</c> + /// with <see cref="SmallSingle.SingleToByte315(float)"/>. This is compatible with /// Lucene's default implementation. If you change this, then you should - /// change <seealso cref="#decodeNormValue(byte)"/> to match. + /// change <see cref="DecodeNormValue(byte)"/> to match. /// </summary> protected internal virtual byte EncodeNormValue(float boost, int fieldLength) { @@ -115,8 +116,8 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// The default implementation returns <code>1 / f<sup>2</sup></code> - /// where <code>f</code> is <seealso cref="SmallSingle#byte315ToFloat(byte)"/>. + /// The default implementation returns <c>1 / f<sup>2</sup></c> + /// where <c>f</c> is <see cref="SmallSingle.Byte315ToSingle(byte)"/>. /// </summary> protected internal virtual float DecodeNormValue(byte b) { @@ -130,9 +131,9 @@ namespace Lucene.Net.Search.Similarities private bool discountOverlaps = true; // LUCENENET specific: made private, since value can be set/get through propery /// <summary> - /// Sets whether overlap tokens (Tokens with 0 position increment) are - /// ignored when computing norm. By default this is true, meaning overlap - /// tokens do not count when computing norms. + /// Gets or Sets whether overlap tokens (Tokens with 0 position increment) are + /// ignored when computing norm. By default this is true, meaning overlap + /// tokens do not count when computing norms. /// </summary> public virtual bool DiscountOverlaps { @@ -169,22 +170,22 @@ namespace Lucene.Net.Search.Similarities /// Computes a score factor for a simple term and returns an explanation /// for that score factor. /// - /// <p> + /// <para/> /// The default implementation uses: /// - /// <pre class="prettyprint"> - /// idf(docFreq, searcher.maxDoc()); - /// </pre> + /// <code> + /// Idf(docFreq, searcher.MaxDoc); + /// </code> /// - /// Note that <seealso cref="CollectionStatistics#maxDoc()"/> is used instead of - /// <seealso cref="Lucene.Net.Index.IndexReader#numDocs() IndexReader#numDocs()"/> because also - /// <seealso cref="TermStatistics#docFreq()"/> is used, and when the latter - /// is inaccurate, so is <seealso cref="CollectionStatistics#maxDoc()"/>, and in the same direction. - /// In addition, <seealso cref="CollectionStatistics#maxDoc()"/> is more efficient to compute + /// Note that <see cref="CollectionStatistics.MaxDoc"/> is used instead of + /// <see cref="Lucene.Net.Index.IndexReader.NumDocs"/> because also + /// <see cref="TermStatistics.DocFreq"/> is used, and when the latter + /// is inaccurate, so is <see cref="CollectionStatistics.MaxDoc"/>, and in the same direction. + /// In addition, <see cref="CollectionStatistics.MaxDoc"/> is more efficient to compute /// </summary> /// <param name="collectionStats"> collection-level statistics </param> /// <param name="termStats"> term-level statistics for the term </param> - /// <returns> an Explain object that includes both an idf score factor + /// <returns> an <see cref="Explanation"/> object that includes both an idf score factor /// and an explanation for the term. </returns> public virtual Explanation IdfExplain(CollectionStatistics collectionStats, TermStatistics termStats) { @@ -197,13 +198,13 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Computes a score factor for a phrase. /// - /// <p> + /// <para/> /// The default implementation sums the idf factor for /// each term in the phrase. /// </summary> /// <param name="collectionStats"> collection-level statistics </param> /// <param name="termStats"> term-level statistics for the terms in the phrase </param> - /// <returns> an Explain object that includes both an idf + /// <returns> an <see cref="Explanation"/> object that includes both an idf /// score factor for the phrase and an explanation /// for each term. </returns> public virtual Explanation IdfExplain(CollectionStatistics collectionStats, TermStatistics[] termStats) @@ -388,8 +389,8 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Returns the <code>k1</code> parameter </summary> - /// <seealso cref= #BM25Similarity(float, float) </seealso> + /// Returns the <c>k1</c> parameter </summary> + /// <seealso cref="BM25Similarity(float, float)"/> public virtual float K1 { get @@ -399,8 +400,8 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Returns the <code>b</code> parameter </summary> - /// <seealso cref= #BM25Similarity(float, float) </seealso> + /// Returns the <c>b</c> parameter </summary> + /// <seealso cref="BM25Similarity(float, float)"/> public virtual float B { get http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BasicModel.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BasicModel.cs b/src/Lucene.Net/Search/Similarities/BasicModel.cs index 5213253..28365de 100644 --- a/src/Lucene.Net/Search/Similarities/BasicModel.cs +++ b/src/Lucene.Net/Search/Similarities/BasicModel.cs @@ -20,13 +20,14 @@ namespace Lucene.Net.Search.Similarities */ /// <summary> - /// this class acts as the base class for the specific <em>basic model</em> + /// This class acts as the base class for the specific <em>basic model</em> /// implementations in the DFR framework. Basic models compute the /// <em>informative content Inf<sub>1</sub> = -log<sub>2</sub>Prob<sub>1</sub> /// </em>. + /// <para/> + /// @lucene.experimental /// </summary> - /// <seealso cref= DFRSimilarity - /// @lucene.experimental </seealso> + /// <seealso cref="DFRSimilarity"/> #if FEATURE_SERIALIZABLE [Serializable] #endif @@ -46,10 +47,10 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Returns an explanation for the score. - /// <p>Most basic models use the number of documents and the total term + /// <para>Most basic models use the number of documents and the total term /// frequency to compute Inf<sub>1</sub>. this method provides a generic /// explanation for such models. Subclasses that use other statistics must - /// override this method.</p> + /// override this method.</para> /// </summary> public virtual Explanation Explain(BasicStats stats, float tfn) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BasicModelBE.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BasicModelBE.cs b/src/Lucene.Net/Search/Similarities/BasicModelBE.cs index bcba387..b0da29a 100644 --- a/src/Lucene.Net/Search/Similarities/BasicModelBE.cs +++ b/src/Lucene.Net/Search/Similarities/BasicModelBE.cs @@ -21,12 +21,14 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Limiting form of the Bose-Einstein model. The formula used in Lucene differs - /// slightly from the one in the original paper: {@code F} is increased by {@code tfn+1} - /// and {@code N} is increased by {@code F} + /// slightly from the one in the original paper: <c>F</c> is increased by <c>tfn+1</c> + /// and <c>N</c> is increased by <c>F</c> + /// <para/> /// @lucene.experimental + /// <para/> /// NOTE: in some corner cases this model may give poor performance with Normalizations that - /// return large values for {@code tfn} such as NormalizationH3. Consider using the - /// geometric approximation (<seealso cref="BasicModelG"/>) instead, which provides the same relevance + /// return large values for <c>tfn</c> such as <see cref="NormalizationH3"/>. Consider using the + /// geometric approximation (<see cref="BasicModelG"/>) instead, which provides the same relevance /// but with less practical problems. /// </summary> #if FEATURE_SERIALIZABLE @@ -45,12 +47,12 @@ namespace Lucene.Net.Search.Similarities double F = stats.TotalTermFreq + 1 + tfn; // approximation only holds true when F << N, so we use N += F double N = F + stats.NumberOfDocuments; - return (float)(-SimilarityBase.Log2((N - 1) * Math.E) + f(N + F - 1, N + F - tfn - 2) - f(F, F - tfn)); + return (float)(-SimilarityBase.Log2((N - 1) * Math.E) + this.F(N + F - 1, N + F - tfn - 2) - this.F(F, F - tfn)); } /// <summary> /// The <em>f</em> helper function defined for <em>B<sub>E</sub></em>. </summary> - private double f(double n, double m) + private double F(double n, double m) { return (m + 0.5) * SimilarityBase.Log2(n / m) + (n - m) * SimilarityBase.Log2(n); } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BasicModelD.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BasicModelD.cs b/src/Lucene.Net/Search/Similarities/BasicModelD.cs index b2dda6b..fc5f4d7 100644 --- a/src/Lucene.Net/Search/Similarities/BasicModelD.cs +++ b/src/Lucene.Net/Search/Similarities/BasicModelD.cs @@ -22,13 +22,14 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Implements the approximation of the binomial model with the divergence /// for DFR. The formula used in Lucene differs slightly from the one in the - /// original paper: to avoid underflow for small values of {@code N} and - /// {@code F}, {@code N} is increased by {@code 1} and - /// {@code F} is always increased by {@code tfn+1}. - /// <p> + /// original paper: to avoid underflow for small values of <c>N</c> and + /// <c>F</c>, <c>N</c> is increased by <c>1</c> and + /// <c>F</c> is always increased by <c>tfn+1</c>. + /// <para/> /// WARNING: for terms that do not meet the expected random distribution /// (e.g. stopwords), this model may give poor performance, such as /// abnormally high scores for low tf values. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BasicModelG.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BasicModelG.cs b/src/Lucene.Net/Search/Similarities/BasicModelG.cs index a2d0a74..d95b2ec 100644 --- a/src/Lucene.Net/Search/Similarities/BasicModelG.cs +++ b/src/Lucene.Net/Search/Similarities/BasicModelG.cs @@ -21,8 +21,9 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Geometric as limiting form of the Bose-Einstein model. The formula used in Lucene differs - /// slightly from the one in the original paper: {@code F} is increased by {@code 1} - /// and {@code N} is increased by {@code F}. + /// slightly from the one in the original paper: <c>F</c> is increased by <c>1</c> + /// and <c>N</c> is increased by <c>F</c>. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BasicModelIF.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BasicModelIF.cs b/src/Lucene.Net/Search/Similarities/BasicModelIF.cs index 89aa9b8..3bf3a8e 100644 --- a/src/Lucene.Net/Search/Similarities/BasicModelIF.cs +++ b/src/Lucene.Net/Search/Similarities/BasicModelIF.cs @@ -21,6 +21,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// An approximation of the <em>I(n<sub>e</sub>)</em> model. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BasicModelIn.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BasicModelIn.cs b/src/Lucene.Net/Search/Similarities/BasicModelIn.cs index 196e929..fac653a 100644 --- a/src/Lucene.Net/Search/Similarities/BasicModelIn.cs +++ b/src/Lucene.Net/Search/Similarities/BasicModelIn.cs @@ -21,6 +21,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// The basic tf-idf model of randomness. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BasicModelIne.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BasicModelIne.cs b/src/Lucene.Net/Search/Similarities/BasicModelIne.cs index 27d15cf..25047b7 100644 --- a/src/Lucene.Net/Search/Similarities/BasicModelIne.cs +++ b/src/Lucene.Net/Search/Similarities/BasicModelIne.cs @@ -22,6 +22,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Tf-idf model of randomness, based on a mixture of Poisson and inverse /// document frequency. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BasicModelP.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BasicModelP.cs b/src/Lucene.Net/Search/Similarities/BasicModelP.cs index 9167bd6..c42cfd3 100644 --- a/src/Lucene.Net/Search/Similarities/BasicModelP.cs +++ b/src/Lucene.Net/Search/Similarities/BasicModelP.cs @@ -21,8 +21,9 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Implements the Poisson approximation for the binomial model for DFR. + /// <para/> /// @lucene.experimental - /// <p> + /// <para/> /// WARNING: for terms that do not meet the expected random distribution /// (e.g. stopwords), this model may give poor performance, such as /// abnormally high scores for low tf values. @@ -33,7 +34,7 @@ namespace Lucene.Net.Search.Similarities public class BasicModelP : BasicModel { /// <summary> - /// {@code log2(Math.E)}, precomputed. </summary> + /// <c>log2(Math.E)</c>, precomputed. </summary> protected internal static double LOG2_E = SimilarityBase.Log2(Math.E); /// <summary> http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/BasicStats.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/BasicStats.cs b/src/Lucene.Net/Search/Similarities/BasicStats.cs index aefef8c..0c534bb 100644 --- a/src/Lucene.Net/Search/Similarities/BasicStats.cs +++ b/src/Lucene.Net/Search/Similarities/BasicStats.cs @@ -21,6 +21,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Stores all statistics commonly used ranking methods. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -28,7 +29,7 @@ namespace Lucene.Net.Search.Similarities #endif public class BasicStats : Similarity.SimWeight { - protected internal readonly string m_field; + protected internal readonly string m_field; // LUCENENET TODO: API This was internal in Lucene /// <summary> /// The number of documents. </summary> @@ -79,7 +80,7 @@ namespace Lucene.Net.Search.Similarities // ------------------------- Getter/setter methods ------------------------- /// <summary> - /// Returns the number of documents. </summary> + /// Gets or Sets the number of documents. </summary> public virtual long NumberOfDocuments { get @@ -94,7 +95,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Returns the total number of tokens in the field. </summary> - /// <seealso cref= Terms#getSumTotalTermFreq() </seealso> + /// <seealso cref="Index.Terms.SumTotalTermFreq"/> public virtual long NumberOfFieldTokens { get @@ -149,7 +150,7 @@ namespace Lucene.Net.Search.Similarities } } - public virtual string Field + public virtual string Field // LUCENENET TODO: API - eliminate and use internal field instead { get { return m_field; } } @@ -158,7 +159,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// The square of the raw normalization value. </summary> - /// <seealso cref= #rawNormalizationValue() </seealso> + /// <seealso cref="RawNormalizationValue()"/> public override float GetValueForNormalization() { float rawValue = RawNormalizationValue(); @@ -166,10 +167,10 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Computes the raw normalization value. this basic implementation returns + /// Computes the raw normalization value. This basic implementation returns /// the query boost. Subclasses may override this method to include other /// factors (such as idf), or to save the value for inclusion in - /// <seealso cref="#normalize(float, float)"/>, etc. + /// <seealso cref="Normalize(float, float)"/>, etc. /// </summary> protected internal virtual float RawNormalizationValue() { @@ -177,7 +178,7 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// No normalization is done. {@code topLevelBoost} is saved in the object, + /// No normalization is done. <paramref name="topLevelBoost"/> is saved in the object, /// however. /// </summary> public override void Normalize(float queryNorm, float topLevelBoost) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/DFRSimilarity.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/DFRSimilarity.cs b/src/Lucene.Net/Search/Similarities/DFRSimilarity.cs index 0e319af..be52875 100644 --- a/src/Lucene.Net/Search/Similarities/DFRSimilarity.cs +++ b/src/Lucene.Net/Search/Similarities/DFRSimilarity.cs @@ -25,53 +25,66 @@ namespace Lucene.Net.Search.Similarities /// Probabilistic models of information retrieval based on measuring the /// divergence from randomness. ACM Trans. Inf. Syst. 20, 4 (October 2002), /// 357-389. - /// <p>The DFR scoring formula is composed of three separate components: the + /// <para>The DFR scoring formula is composed of three separate components: the /// <em>basic model</em>, the <em>aftereffect</em> and an additional /// <em>normalization</em> component, represented by the classes - /// {@code BasicModel}, {@code AfterEffect} and {@code Normalization}, + /// <see cref="Similarities.BasicModel"/>, <see cref="Similarities.AfterEffect"/> and <see cref="Similarities.Normalization"/>, /// respectively. The names of these classes were chosen to match the names of - /// their counterparts in the Terrier IR engine.</p> - /// <p>To construct a DFRSimilarity, you must specify the implementations for + /// their counterparts in the Terrier IR engine.</para> + /// <para>To construct a <see cref="DFRSimilarity"/>, you must specify the implementations for /// all three components of DFR: - /// <ol> - /// <li><seealso cref="BasicModel"/>: Basic model of information content: - /// <ul> - /// <li><seealso cref="BasicModelBE"/>: Limiting form of Bose-Einstein - /// <li><seealso cref="BasicModelG"/>: Geometric approximation of Bose-Einstein - /// <li><seealso cref="BasicModelP"/>: Poisson approximation of the Binomial - /// <li><seealso cref="BasicModelD"/>: Divergence approximation of the Binomial - /// <li><seealso cref="BasicModelIn"/>: Inverse document frequency - /// <li><seealso cref="BasicModelIne"/>: Inverse expected document - /// frequency [mixture of Poisson and IDF] - /// <li><seealso cref="BasicModelIF"/>: Inverse term frequency - /// [approximation of I(ne)] - /// </ul> - /// <li><seealso cref="AfterEffect"/>: First normalization of information - /// gain: - /// <ul> - /// <li><seealso cref="AfterEffectL"/>: Laplace's law of succession - /// <li><seealso cref="AfterEffectB"/>: Ratio of two Bernoulli processes - /// <li><seealso cref="NoAfterEffect"/>: no first normalization - /// </ul> - /// <li><seealso cref="Normalization"/>: Second (length) normalization: - /// <ul> - /// <li><seealso cref="NormalizationH1"/>: Uniform distribution of term - /// frequency - /// <li><seealso cref="NormalizationH2"/>: term frequency density inversely - /// related to length - /// <li><seealso cref="NormalizationH3"/>: term frequency normalization - /// provided by Dirichlet prior - /// <li><seealso cref="NormalizationZ"/>: term frequency normalization provided - /// by a Zipfian relation - /// <li><seealso cref="NoNormalization"/>: no second normalization - /// </ul> - /// </ol> - /// <p>Note that <em>qtf</em>, the multiplicity of term-occurrence in the query, - /// is not handled by this implementation.</p> </summary> - /// <seealso cref= BasicModel </seealso> - /// <seealso cref= AfterEffect </seealso> - /// <seealso cref= Normalization - /// @lucene.experimental </seealso> + /// <list type="table"> + /// <listheader> + /// <term>Component</term> + /// <term>Implementations</term> + /// </listheader> + /// <item> + /// <term><see cref="Similarities.BasicModel"/>: Basic model of information content:</term> + /// <term> + /// <list type="bullet"> + /// <item><description><see cref="BasicModelBE"/>: Limiting form of Bose-Einstein</description></item> + /// <item><description><see cref="BasicModelG"/>: Geometric approximation of Bose-Einstein</description></item> + /// <item><description><see cref="BasicModelP"/>: Poisson approximation of the Binomial</description></item> + /// <item><description><see cref="BasicModelD"/>: Divergence approximation of the Binomial</description></item> + /// <item><description><see cref="BasicModelIn"/>: Inverse document frequency</description></item> + /// <item><description><see cref="BasicModelIne"/>: Inverse expected document frequency [mixture of Poisson and IDF]</description></item> + /// <item><description><see cref="BasicModelIF"/>: Inverse term frequency [approximation of I(ne)]</description></item> + /// </list> + /// </term> + /// </item> + /// <item> + /// <term><see cref="Similarities.AfterEffect"/>: First normalization of information gain:</term> + /// <term> + /// <list type="bullet"> + /// <item><description><see cref="AfterEffectL"/>: Laplace's law of succession</description></item> + /// <item><description><see cref="AfterEffectB"/>: Ratio of two Bernoulli processes</description></item> + /// <item><description><see cref="AfterEffect.NoAfterEffect"/>: no first normalization</description></item> + /// </list> + /// </term> + /// </item> + /// <item> + /// <term><see cref="Similarities.Normalization"/>: Second (length) normalization:</term> + /// <term> + /// <list type="bullet"> + /// <item><description><see cref="NormalizationH1"/>: Uniform distribution of term frequency</description></item> + /// <item><description><see cref="NormalizationH2"/>: term frequency density inversely related to length</description></item> + /// <item><description><see cref="NormalizationH3"/>: term frequency normalization provided by Dirichlet prior</description></item> + /// <item><description><see cref="NormalizationZ"/>: term frequency normalization provided by a Zipfian relation</description></item> + /// <item><description><see cref="Normalization.NoNormalization"/>: no second normalization</description></item> + /// </list> + /// </term> + /// </item> + /// </list> + /// + /// </para> + /// <para>Note that <em>qtf</em>, the multiplicity of term-occurrence in the query, + /// is not handled by this implementation. + /// </para> + /// @lucene.experimental + /// </summary> + /// <seealso cref="Similarities.BasicModel"/> + /// <seealso cref="Similarities.AfterEffect"/> + /// <seealso cref="Similarities.Normalization"/> #if FEATURE_SERIALIZABLE [Serializable] #endif @@ -91,10 +104,10 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Creates DFRSimilarity from the three components. - /// <p> - /// Note that <code>null</code> values are not allowed: + /// <para/> + /// Note that <c>null</c> values are not allowed: /// if you want no normalization or after-effect, instead pass - /// <seealso cref="NoNormalization"/> or <seealso cref="NoAfterEffect"/> respectively. </summary> + /// <see cref="Normalization.NoNormalization"/> or <see cref="AfterEffect.NoAfterEffect"/> respectively. </summary> /// <param name="basicModel"> Basic model of information content </param> /// <param name="afterEffect"> First normalization of information gain </param> /// <param name="normalization"> Second (length) normalization </param> http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/DefaultSimilarity.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/DefaultSimilarity.cs b/src/Lucene.Net/Search/Similarities/DefaultSimilarity.cs index 3b290ec..a0b297f 100644 --- a/src/Lucene.Net/Search/Similarities/DefaultSimilarity.cs +++ b/src/Lucene.Net/Search/Similarities/DefaultSimilarity.cs @@ -24,25 +24,25 @@ namespace Lucene.Net.Search.Similarities using SmallSingle = Lucene.Net.Util.SmallSingle; /// <summary> - /// Expert: Default scoring implementation which {@link #encodeNormValue(float) - /// encodes} norm values as a single byte before being stored. At search time, + /// Expert: Default scoring implementation which encodes (<see cref="EncodeNormValue(float)"/>) + /// norm values as a single byte before being stored. At search time, /// the norm byte value is read from the index - /// <seealso cref="Lucene.Net.Store.Directory directory"/> and - /// <seealso cref="#decodeNormValue(long) decoded"/> back to a float <i>norm</i> value. + /// <see cref="Lucene.Net.Store.Directory"/> and + /// decoded (<see cref="DecodeNormValue(long)"/>) back to a float <i>norm</i> value. /// this encoding/decoding, while reducing index size, comes with the price of - /// precision loss - it is not guaranteed that <i>decode(encode(x)) = x</i>. For - /// instance, <i>decode(encode(0.89)) = 0.75</i>. - /// <p> + /// precision loss - it is not guaranteed that <i>Decode(Encode(x)) = x</i>. For + /// instance, <i>Decode(Encode(0.89)) = 0.75</i>. + /// <para/> /// Compression of norm values to a single byte saves memory at search time, /// because once a field is referenced at search time, its norms - for all /// documents - are maintained in memory. - /// <p> + /// <para/> /// The rationale supporting such lossy compression of norm values is that given /// the difficulty (and inaccuracy) of users to express their true information - /// need by a query, only big differences matter. <br> - /// <br> + /// need by a query, only big differences matter. + /// <para/> /// Last, note that search time is too late to modify this <i>norm</i> part of - /// scoring, e.g. by using a different <seealso cref="Similarity"/> for search. + /// scoring, e.g. by using a different <see cref="Similarity"/> for search. /// </summary> #if FEATURE_SERIALIZABLE [Serializable] @@ -68,14 +68,14 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Implemented as <code>overlap / maxOverlap</code>. </summary> + /// Implemented as <c>overlap / maxOverlap</c>. </summary> public override float Coord(int overlap, int maxOverlap) { return overlap / (float)maxOverlap; } /// <summary> - /// Implemented as <code>1/sqrt(sumOfSquaredWeights)</code>. </summary> + /// Implemented as <c>1/sqrt(sumOfSquaredWeights)</c>. </summary> public override float QueryNorm(float sumOfSquaredWeights) { return (float)(1.0 / Math.Sqrt(sumOfSquaredWeights)); @@ -83,7 +83,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Encodes a normalization factor for storage in an index. - /// <p> + /// <para/> /// The encoding uses a three-bit mantissa, a five-bit exponent, and the /// zero-exponent point at 15, thus representing values from around 7x10^9 to /// 2x10^-9 with about one significant decimal digit of accuracy. Zero is also @@ -92,8 +92,8 @@ namespace Lucene.Net.Search.Similarities /// values too small to represent are rounded up to the smallest positive /// representable value. /// </summary> - /// <seealso cref= Lucene.Net.Document.Field#setBoost(float) </seealso> - /// <seealso cref= Lucene.Net.Util.SmallSingle </seealso> + /// <seealso cref="Lucene.Net.Documents.Field.Boost"/> + /// <seealso cref="Lucene.Net.Util.SmallSingle"/> public override sealed long EncodeNormValue(float f) { return SmallSingle.SingleToSByte315(f); @@ -102,7 +102,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Decodes the norm value, assuming it is a single byte. /// </summary> - /// <seealso cref= #encodeNormValue(float) </seealso> + /// <seealso cref="EncodeNormValue(float)"/> public override sealed float DecodeNormValue(long norm) { return NORM_TABLE[(int)(norm & 0xFF)]; // & 0xFF maps negative bytes to positive above 127 @@ -110,13 +110,14 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Implemented as - /// <code>state.getBoost()*lengthNorm(numTerms)</code>, where - /// <code>numTerms</code> is <seealso cref="FieldInvertState#getLength()"/> if {@link - /// #setDiscountOverlaps} is false, else it's {@link - /// FieldInvertState#getLength()} - {@link - /// FieldInvertState#getNumOverlap()}. + /// <c>state.Boost * LengthNorm(numTerms)</c>, where + /// <c>numTerms</c> is <see cref="FieldInvertState.Length"/> if + /// <see cref="DiscountOverlaps"/> is <c>false</c>, else it's + /// <see cref="FieldInvertState.Length"/> - + /// <see cref="FieldInvertState.NumOverlap"/>. /// - /// @lucene.experimental + /// <para/> + /// @lucene.experimental /// </summary> public override float LengthNorm(FieldInvertState state) { @@ -133,48 +134,48 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Implemented as <code>sqrt(freq)</code>. </summary> + /// Implemented as <c>Math.Sqrt(freq)</c>. </summary> public override float Tf(float freq) { return (float)Math.Sqrt(freq); } /// <summary> - /// Implemented as <code>1 / (distance + 1)</code>. </summary> + /// Implemented as <c>1 / (distance + 1)</c>. </summary> public override float SloppyFreq(int distance) { return 1.0f / (distance + 1); } /// <summary> - /// The default implementation returns <code>1</code> </summary> + /// The default implementation returns <c>1</c> </summary> public override float ScorePayload(int doc, int start, int end, BytesRef payload) { return 1; } /// <summary> - /// Implemented as <code>log(numDocs/(docFreq+1)) + 1</code>. </summary> + /// Implemented as <c>log(numDocs/(docFreq+1)) + 1</c>. </summary> public override float Idf(long docFreq, long numDocs) { return (float)(Math.Log(numDocs / (double)(docFreq + 1)) + 1.0); } /// <summary> - /// True if overlap tokens (tokens with a position of increment of zero) are + /// <c>True</c> if overlap tokens (tokens with a position of increment of zero) are /// discounted from the document's length. /// </summary> protected bool m_discountOverlaps = true; /// <summary> /// Determines whether overlap tokens (Tokens with - /// 0 position increment) are ignored when computing - /// norm. By default this is true, meaning overlap - /// tokens do not count when computing norms. - /// - /// @lucene.experimental + /// 0 position increment) are ignored when computing + /// norm. By default this is true, meaning overlap + /// tokens do not count when computing norms. + /// <para/> + /// @lucene.experimental /// </summary> - /// <seealso cref= #computeNorm </seealso> + /// <seealso cref="TFIDFSimilarity.ComputeNorm(FieldInvertState)"/> public virtual bool DiscountOverlaps { set http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/Distribution.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/Distribution.cs b/src/Lucene.Net/Search/Similarities/Distribution.cs index 1b2c3e4..ee92b13 100644 --- a/src/Lucene.Net/Search/Similarities/Distribution.cs +++ b/src/Lucene.Net/Search/Similarities/Distribution.cs @@ -21,9 +21,11 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// The probabilistic distribution used to model term occurrence - /// in information-based models. </summary> - /// <seealso cref= IBSimilarity - /// @lucene.experimental </seealso> + /// in information-based models. + /// <para/> + /// @lucene.experimental + /// </summary> + /// <seealso cref="IBSimilarity"/> #if FEATURE_SERIALIZABLE [Serializable] #endif @@ -43,7 +45,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Explains the score. Returns the name of the model only, since - /// both {@code tfn} and {@code lambda} are explained elsewhere. + /// both <c>tfn</c> and <c>lambda</c> are explained elsewhere. /// </summary> public virtual Explanation Explain(BasicStats stats, float tfn, float lambda) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/DistributionLL.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/DistributionLL.cs b/src/Lucene.Net/Search/Similarities/DistributionLL.cs index 2841d2a..ed8ddea 100644 --- a/src/Lucene.Net/Search/Similarities/DistributionLL.cs +++ b/src/Lucene.Net/Search/Similarities/DistributionLL.cs @@ -21,9 +21,9 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Log-logistic distribution. - /// <p>Unlike for DFR, the natural logarithm is used, as + /// <para>Unlike for DFR, the natural logarithm is used, as /// it is faster to compute and the original paper does not express any - /// preference to a specific base.</p> + /// preference to a specific base.</para> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/DistributionSPL.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/DistributionSPL.cs b/src/Lucene.Net/Search/Similarities/DistributionSPL.cs index 55c7639..ade1b05 100644 --- a/src/Lucene.Net/Search/Similarities/DistributionSPL.cs +++ b/src/Lucene.Net/Search/Similarities/DistributionSPL.cs @@ -22,9 +22,9 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// The smoothed power-law (SPL) distribution for the information-based framework /// that is described in the original paper. - /// <p>Unlike for DFR, the natural logarithm is used, as + /// <para>Unlike for DFR, the natural logarithm is used, as /// it is faster to compute and the original paper does not express any - /// preference to a specific base.</p> + /// preference to a specific base.</para> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/IBSimilarity.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/IBSimilarity.cs b/src/Lucene.Net/Search/Similarities/IBSimilarity.cs index fecf57a..19223ee 100644 --- a/src/Lucene.Net/Search/Similarities/IBSimilarity.cs +++ b/src/Lucene.Net/Search/Similarities/IBSimilarity.cs @@ -22,51 +22,64 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Provides a framework for the family of information-based models, as described - /// in Stéphane Clinchant and Eric Gaussier. 2010. Information-based + /// in StÉphane Clinchant and Eric Gaussier. 2010. Information-based /// models for ad hoc IR. In Proceeding of the 33rd international ACM SIGIR /// conference on Research and development in information retrieval (SIGIR '10). /// ACM, New York, NY, USA, 234-241. - /// <p>The retrieval function is of the form <em>RSV(q, d) = ∑ + /// <para>The retrieval function is of the form <em>RSV(q, d) = ∑ /// -x<sup>q</sup><sub>w</sub> log Prob(X<sub>w</sub> >= - /// t<sup>d</sup><sub>w</sub> | λ<sub>w</sub>)</em>, where - /// <ul> - /// <li><em>x<sup>q</sup><sub>w</sub></em> is the query boost;</li> - /// <li><em>X<sub>w</sub></em> is a random variable that counts the occurrences - /// of word <em>w</em>;</li> - /// <li><em>t<sup>d</sup><sub>w</sub></em> is the normalized term frequency;</li> - /// <li><em>λ<sub>w</sub></em> is a parameter.</li> - /// </ul> - /// </p> - /// <p>The framework described in the paper has many similarities to the DFR - /// framework (see <seealso cref="DFRSimilarity"/>). It is possible that the two - /// Similarities will be merged at one point.</p> - /// <p>To construct an IBSimilarity, you must specify the implementations for + /// t<sup>d</sup><sub>w</sub> | λ<sub>w</sub>)</em>, where + /// <list type="bullet"> + /// <item><description><em>x<sup>q</sup><sub>w</sub></em> is the query boost;</description></item> + /// <item><description><em>X<sub>w</sub></em> is a random variable that counts the occurrences + /// of word <em>w</em>;</description></item> + /// <item><description><em>t<sup>d</sup><sub>w</sub></em> is the normalized term frequency;</description></item> + /// <item><description><em>λ<sub>w</sub></em> is a parameter.</description></item> + /// </list> + /// </para> + /// <para>The framework described in the paper has many similarities to the DFR + /// framework (see <see cref="DFRSimilarity"/>). It is possible that the two + /// Similarities will be merged at one point.</para> + /// <para>To construct an <see cref="IBSimilarity"/>, you must specify the implementations for /// all three components of the Information-Based model. - /// <ol> - /// <li><seealso cref="Distribution"/>: Probabilistic distribution used to - /// model term occurrence - /// <ul> - /// <li><seealso cref="DistributionLL"/>: Log-logistic</li> - /// <li><seealso cref="DistributionLL"/>: Smoothed power-law</li> - /// </ul> - /// </li> - /// <li><seealso cref="Lambda"/>: λ<sub>w</sub> parameter of the - /// probability distribution - /// <ul> - /// <li><seealso cref="LambdaDF"/>: <code>N<sub>w</sub>/N</code> or average - /// number of documents where w occurs</li> - /// <li><seealso cref="LambdaTTF"/>: <code>F<sub>w</sub>/N</code> or - /// average number of occurrences of w in the collection</li> - /// </ul> - /// </li> - /// <li><seealso cref="Normalization"/>: Term frequency normalization - /// <blockquote>Any supported DFR normalization (listed in - /// <seealso cref="DFRSimilarity"/>)</blockquote> - /// </li> - /// </ol> - /// <p> </summary> - /// <seealso cref= DFRSimilarity - /// @lucene.experimental </seealso> + /// <list type="table"> + /// <listheader> + /// <term>Component</term> + /// <term>Implementations</term> + /// </listheader> + /// <item> + /// <term><see cref="Distribution"/>: Probabilistic distribution used to + /// model term occurrence</term> + /// <term> + /// <list type="bullet"> + /// <item><description><see cref="DistributionLL"/>: Log-logistic</description></item> + /// <item><description><see cref="DistributionLL"/>: Smoothed power-law</description></item> + /// </list> + /// </term> + /// </item> + /// <item> + /// <term><see cref="Lambda"/>: λ<sub>w</sub> parameter of the + /// probability distribution</term> + /// <term> + /// <list type="bullet"> + /// <item><description><see cref="LambdaDF"/>: <c>N<sub>w</sub>/N</c> or average + /// number of documents where w occurs</description></item> + /// <item><description><see cref="LambdaTTF"/>: <c>F<sub>w</sub>/N</c> or + /// average number of occurrences of w in the collection</description></item> + /// </list> + /// </term> + /// </item> + /// <item> + /// <term><see cref="Normalization"/>: Term frequency normalization</term> + /// <term>Any supported DFR normalization (listed in + /// <see cref="DFRSimilarity"/>) + /// </term> + /// </item> + /// </list> + /// </para> + /// @lucene.experimental + /// </summary> + /// <seealso cref="DFRSimilarity"/> [ExceptionToClassNameConvention] #if FEATURE_SERIALIZABLE [Serializable] @@ -78,7 +91,7 @@ namespace Lucene.Net.Search.Similarities protected internal readonly Distribution m_distribution; /// <summary> - /// The <em>lambda (λ<sub>w</sub>)</em> parameter. </summary> + /// The <em>lambda (λ<sub>w</sub>)</em> parameter. </summary> protected internal readonly Lambda m_lambda; /// <summary> @@ -87,12 +100,12 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Creates IBSimilarity from the three components. - /// <p> - /// Note that <code>null</code> values are not allowed: + /// <para/> + /// Note that <c>null</c> values are not allowed: /// if you want no normalization, instead pass - /// <seealso cref="NoNormalization"/>. </summary> + /// <see cref="Normalization.NoNormalization"/>. </summary> /// <param name="distribution"> probabilistic distribution modeling term occurrence </param> - /// <param name="lambda"> distribution's λ<sub>w</sub> parameter </param> + /// <param name="lambda"> distribution's λ<sub>w</sub> parameter </param> /// <param name="normalization"> term frequency normalization </param> public IBSimilarity(Distribution distribution, Lambda lambda, Normalization normalization) { @@ -121,9 +134,9 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// The name of IB methods follow the pattern - /// {@code IB <distribution> <lambda><normalization>}. The name of the + /// <c>IB <distribution> <lambda><normalization></c>. The name of the /// distribution is the same as in the original paper; for the names of lambda - /// parameters, refer to the javadoc of the <seealso cref="Lambda"/> classes. + /// parameters, refer to the doc of the <see cref="Similarities.Lambda"/> classes. /// </summary> public override string ToString() { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/LMDirichletSimilarity.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/LMDirichletSimilarity.cs b/src/Lucene.Net/Search/Similarities/LMDirichletSimilarity.cs index 8a2da89..322f77b 100644 --- a/src/Lucene.Net/Search/Similarities/LMDirichletSimilarity.cs +++ b/src/Lucene.Net/Search/Similarities/LMDirichletSimilarity.cs @@ -27,12 +27,12 @@ namespace Lucene.Net.Search.Similarities /// Ad Hoc information retrieval. In Proceedings of the 24th annual international /// ACM SIGIR conference on Research and development in information retrieval /// (SIGIR '01). ACM, New York, NY, USA, 334-342. - /// <p> + /// <para> /// The formula as defined the paper assigns a negative score to documents that /// contain the term, but with fewer occurrences than predicted by the collection - /// language model. The Lucene implementation returns {@code 0} for such + /// language model. The Lucene implementation returns <c>0</c> for such /// documents. - /// </p> + /// </para> /// /// @lucene.experimental /// </summary> @@ -42,11 +42,11 @@ namespace Lucene.Net.Search.Similarities public class LMDirichletSimilarity : LMSimilarity { /// <summary> - /// The μ parameter. </summary> + /// The μ parameter. </summary> private readonly float mu; /// <summary> - /// Instantiates the similarity with the provided μ parameter. </summary> + /// Instantiates the similarity with the provided μ parameter. </summary> public LMDirichletSimilarity(ICollectionModel collectionModel, float mu) : base(collectionModel) { @@ -54,21 +54,21 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Instantiates the similarity with the provided μ parameter. </summary> + /// Instantiates the similarity with the provided μ parameter. </summary> public LMDirichletSimilarity(float mu) { this.mu = mu; } /// <summary> - /// Instantiates the similarity with the default μ value of 2000. </summary> + /// Instantiates the similarity with the default μ value of 2000. </summary> public LMDirichletSimilarity(ICollectionModel collectionModel) : this(collectionModel, 2000) { } /// <summary> - /// Instantiates the similarity with the default μ value of 2000. </summary> + /// Instantiates the similarity with the default μ value of 2000. </summary> public LMDirichletSimilarity() : this(2000) { @@ -97,7 +97,7 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Returns the μ parameter. </summary> + /// Returns the μ parameter. </summary> public virtual float Mu { get http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/LMJelinekMercerSimilarity.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/LMJelinekMercerSimilarity.cs b/src/Lucene.Net/Search/Similarities/LMJelinekMercerSimilarity.cs index e932190..108f0d0 100644 --- a/src/Lucene.Net/Search/Similarities/LMJelinekMercerSimilarity.cs +++ b/src/Lucene.Net/Search/Similarities/LMJelinekMercerSimilarity.cs @@ -27,9 +27,9 @@ namespace Lucene.Net.Search.Similarities /// models applied to Ad Hoc information retrieval. In Proceedings of the 24th /// annual international ACM SIGIR conference on Research and development in /// information retrieval (SIGIR '01). ACM, New York, NY, USA, 334-342. - /// <p>The model has a single parameter, λ. According to said paper, the + /// <para>The model has a single parameter, λ. According to said paper, the /// optimal value depends on both the collection and the query. The optimal value - /// is around {@code 0.1} for title queries and {@code 0.7} for long queries.</p> + /// is around <c>0.1</c> for title queries and <c>0.7</c> for long queries.</para> /// /// @lucene.experimental /// </summary> @@ -39,11 +39,11 @@ namespace Lucene.Net.Search.Similarities public class LMJelinekMercerSimilarity : LMSimilarity { /// <summary> - /// The λ parameter. </summary> + /// The λ parameter. </summary> private readonly float lambda; /// <summary> - /// Instantiates with the specified collectionModel and λ parameter. </summary> + /// Instantiates with the specified <paramref name="collectionModel"/> and λ parameter. </summary> public LMJelinekMercerSimilarity(ICollectionModel collectionModel, float lambda) : base(collectionModel) { @@ -51,7 +51,7 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Instantiates with the specified λ parameter. </summary> + /// Instantiates with the specified λ parameter. </summary> public LMJelinekMercerSimilarity(float lambda) { this.lambda = lambda; @@ -73,7 +73,7 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Returns the λ parameter. </summary> + /// Returns the λ parameter. </summary> public virtual float Lambda { get http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/LMSimilarity.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/LMSimilarity.cs b/src/Lucene.Net/Search/Similarities/LMSimilarity.cs index 6c0e3d9..721d576 100644 --- a/src/Lucene.Net/Search/Similarities/LMSimilarity.cs +++ b/src/Lucene.Net/Search/Similarities/LMSimilarity.cs @@ -23,16 +23,16 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Abstract superclass for language modeling Similarities. The following inner /// types are introduced: - /// <ul> - /// <li><seealso cref="LMStats"/>, which defines a new statistic, the probability that - /// the collection language model generates the current term;</li> - /// <li><seealso cref="ICollectionModel"/>, which is a strategy interface for object that - /// compute the collection language model {@code p(w|C)};</li> - /// <li><seealso cref="DefaultCollectionModel"/>, an implementation of the former, that - /// computes the term probability as the number of occurrences of the term in the - /// collection, divided by the total number of tokens.</li> - /// </ul> - /// + /// <list type="bullet"> + /// <item><description><see cref="LMStats"/>, which defines a new statistic, the probability that + /// the collection language model generates the current term;</description></item> + /// <item><description><see cref="ICollectionModel"/>, which is a strategy interface for object that + /// compute the collection language model <c>p(w|C)</c>;</description></item> + /// <item><description><see cref="DefaultCollectionModel"/>, an implementation of the former, that + /// computes the term probability as the number of occurrences of the term in the + /// collection, divided by the total number of tokens.</description></item> + /// </list> + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -82,16 +82,16 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Returns the name of the LM method. The values of the parameters should be /// included as well. - /// <p>Used in <seealso cref="#toString()"/></p>. + /// <para>Used in <see cref="ToString()"/></para>. /// </summary> public abstract string GetName(); /// <summary> /// Returns the name of the LM method. If a custom collection model strategy is /// used, its name is included as well. </summary> - /// <seealso cref= #getName() </seealso> - /// <seealso cref= CollectionModel#getName() </seealso> - /// <seealso cref= DefaultCollectionModel </seealso> + /// <seealso cref="GetName()"/> + /// <seealso cref="ICollectionModel.Name"/> + /// <seealso cref="DefaultCollectionModel"/> public override string ToString() { string coll = m_collectionModel.Name; @@ -117,7 +117,7 @@ namespace Lucene.Net.Search.Similarities private float collectionProbability; /// <summary> - /// Creates LMStats for the provided field and query-time boost + /// Creates <see cref="LMStats"/> for the provided field and query-time boost /// </summary> public LMStats(string field, float queryBoost) : base(field, queryBoost) @@ -146,19 +146,19 @@ namespace Lucene.Net.Search.Similarities public interface ICollectionModel { /// <summary> - /// Computes the probability {@code p(w|C)} according to the language model + /// Computes the probability <c>p(w|C)</c> according to the language model /// strategy for the current term. /// </summary> float ComputeProbability(BasicStats stats); /// <summary> /// The name of the collection model strategy. </summary> - string Name { get; } + string Name { get; } // LUCENENET TODO: API Change to GetName() ? (consistency) } /// <summary> - /// Models {@code p(w|C)} as the number of occurrences of the term in the - /// collection, divided by the total number of tokens {@code + 1}. + /// Models <c>p(w|C)</c> as the number of occurrences of the term in the + /// collection, divided by the total number of tokens <c>+ 1</c>. /// </summary> #if FEATURE_SERIALIZABLE [Serializable] http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/Lambda.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/Lambda.cs b/src/Lucene.Net/Search/Similarities/Lambda.cs index 1621113..12d1976 100644 --- a/src/Lucene.Net/Search/Similarities/Lambda.cs +++ b/src/Lucene.Net/Search/Similarities/Lambda.cs @@ -20,10 +20,12 @@ namespace Lucene.Net.Search.Similarities */ /// <summary> - /// The <em>lambda (λ<sub>w</sub>)</em> parameter in information-based - /// models. </summary> - /// <seealso cref= IBSimilarity - /// @lucene.experimental </seealso> + /// The <em>lambda (λ<sub>w</sub>)</em> parameter in information-based + /// models. + /// <para/> + /// @lucene.experimental + /// </summary> + /// <seealso cref="IBSimilarity"/> #if FEATURE_SERIALIZABLE [Serializable] #endif http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/LambdaDF.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/LambdaDF.cs b/src/Lucene.Net/Search/Similarities/LambdaDF.cs index f6c43f5..49404f6 100644 --- a/src/Lucene.Net/Search/Similarities/LambdaDF.cs +++ b/src/Lucene.Net/Search/Similarities/LambdaDF.cs @@ -20,7 +20,8 @@ namespace Lucene.Net.Search.Similarities */ /// <summary> - /// Computes lambda as {@code docFreq+1 / numberOfDocuments+1}. + /// Computes lambda as <c>docFreq+1 / numberOfDocuments+1</c>. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/LambdaTTF.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/LambdaTTF.cs b/src/Lucene.Net/Search/Similarities/LambdaTTF.cs index 6f398bd..f65705b 100644 --- a/src/Lucene.Net/Search/Similarities/LambdaTTF.cs +++ b/src/Lucene.Net/Search/Similarities/LambdaTTF.cs @@ -20,7 +20,8 @@ namespace Lucene.Net.Search.Similarities */ /// <summary> - /// Computes lambda as {@code totalTermFreq+1 / numberOfDocuments+1}. + /// Computes lambda as <c>totalTermFreq+1 / numberOfDocuments+1</c>. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/MultiSimilarity.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/MultiSimilarity.cs b/src/Lucene.Net/Search/Similarities/MultiSimilarity.cs index 6064822..49fb5d9 100644 --- a/src/Lucene.Net/Search/Similarities/MultiSimilarity.cs +++ b/src/Lucene.Net/Search/Similarities/MultiSimilarity.cs @@ -27,6 +27,7 @@ namespace Lucene.Net.Search.Similarities /// Implements the CombSUM method for combining evidence from multiple /// similarity values described in: Joseph A. Shaw, Edward A. Fox. /// In Text REtrieval Conference (1993), pp. 243-252 + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -39,8 +40,8 @@ namespace Lucene.Net.Search.Similarities protected internal readonly Similarity[] m_sims; /// <summary> - /// Creates a MultiSimilarity which will sum the scores - /// of the provided <code>sims</code>. + /// Creates a <see cref="MultiSimilarity"/> which will sum the scores + /// of the provided <paramref name="sims"/>. /// </summary> public MultiSimilarity(Similarity[] sims) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/Normalization.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/Normalization.cs b/src/Lucene.Net/Search/Similarities/Normalization.cs index d1a9cce..c80158e 100644 --- a/src/Lucene.Net/Search/Similarities/Normalization.cs +++ b/src/Lucene.Net/Search/Similarities/Normalization.cs @@ -20,11 +20,12 @@ namespace Lucene.Net.Search.Similarities */ /// <summary> - /// this class acts as the base class for the implementations of the term + /// This class acts as the base class for the implementations of the term /// frequency normalization methods in the DFR framework. + /// <para/> + /// @lucene.experimental /// </summary> - /// <seealso cref= DFRSimilarity - /// @lucene.experimental </seealso> + /// <seealso cref="DFRSimilarity"/> #if FEATURE_SERIALIZABLE [Serializable] #endif @@ -45,10 +46,10 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Returns an explanation for the normalized term frequency. - /// <p>The default normalization methods use the field length of the document + /// <para>The default normalization methods use the field length of the document /// and the average field length to compute the normalized term frequency. - /// this method provides a generic explanation for such methods. - /// Subclasses that use other statistics must override this method.</p> + /// This method provides a generic explanation for such methods. + /// Subclasses that use other statistics must override this method.</para> /// </summary> public virtual Explanation Explain(BasicStats stats, float tf, float len) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/NormalizationH1.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/NormalizationH1.cs b/src/Lucene.Net/Search/Similarities/NormalizationH1.cs index 65a24ae..6a0a160 100644 --- a/src/Lucene.Net/Search/Similarities/NormalizationH1.cs +++ b/src/Lucene.Net/Search/Similarities/NormalizationH1.cs @@ -21,12 +21,12 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Normalization model that assumes a uniform distribution of the term frequency. - /// <p>While this model is parameterless in the + /// <para>While this model is parameterless in the /// <a href="http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.101.742";> /// original article</a>, <a href="http://dl.acm.org/citation.cfm?id=1835490";> - /// information-based models</a> (see <seealso cref="IBSimilarity"/>) introduced a + /// information-based models</a> (see <see cref="IBSimilarity"/>) introduced a /// multiplying factor. - /// The default value for the {@code c} parameter is {@code 1}.</p> + /// The default value for the <c>c</c> parameter is <c>1</c>.</para> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -37,8 +37,8 @@ namespace Lucene.Net.Search.Similarities private readonly float c; /// <summary> - /// Creates NormalizationH1 with the supplied parameter <code>c</code>. </summary> - /// <param name="c"> hyper-parameter that controls the term frequency + /// Creates <see cref="NormalizationH1"/> with the supplied parameter <paramref name="c"/>. </summary> + /// <param name="c"> Hyper-parameter that controls the term frequency /// normalization with respect to the document length. </param> public NormalizationH1(float c) { @@ -46,7 +46,7 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Calls <seealso cref="#NormalizationH1(float) NormalizationH1(1)"/> + /// Calls <see cref="T:NormalizationH1(1)"/> /// </summary> public NormalizationH1() : this(1) @@ -64,8 +64,8 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Returns the <code>c</code> parameter. </summary> - /// <seealso cref= #NormalizationH1(float) </seealso> + /// Returns the <c>c</c> parameter. </summary> + /// <seealso cref="NormalizationH1(float)"/> public virtual float C { get http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/NormalizationH2.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/NormalizationH2.cs b/src/Lucene.Net/Search/Similarities/NormalizationH2.cs index a12ddd6..2a43ec5 100644 --- a/src/Lucene.Net/Search/Similarities/NormalizationH2.cs +++ b/src/Lucene.Net/Search/Similarities/NormalizationH2.cs @@ -22,11 +22,11 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Normalization model in which the term frequency is inversely related to the /// length. - /// <p>While this model is parameterless in the + /// <para>While this model is parameterless in the /// <a href="http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.101.742";> /// original article</a>, the <a href="http://theses.gla.ac.uk/1570/";>thesis</a> /// introduces the parameterized variant. - /// The default value for the {@code c} parameter is {@code 1}.</p> + /// The default value for the <c>c</c> parameter is <c>1</c>.</para> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -37,8 +37,8 @@ namespace Lucene.Net.Search.Similarities private readonly float c; /// <summary> - /// Creates NormalizationH2 with the supplied parameter <code>c</code>. </summary> - /// <param name="c"> hyper-parameter that controls the term frequency + /// Creates <see cref="NormalizationH2"/> with the supplied parameter <paramref name="c"/>. </summary> + /// <param name="c"> Hyper-parameter that controls the term frequency /// normalization with respect to the document length. </param> public NormalizationH2(float c) { @@ -46,7 +46,7 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Calls <seealso cref="#NormalizationH2(float) NormalizationH2(1)"/> + /// Calls <see cref="T:NormalizationH2(1)"/> /// </summary> public NormalizationH2() : this(1) @@ -64,8 +64,8 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Returns the <code>c</code> parameter. </summary> - /// <seealso cref= #NormalizationH2(float) </seealso> + /// Returns the <c>c</c> parameter. </summary> + /// <seealso cref="NormalizationH2(float)"/> public virtual float C { get http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/NormalizationH3.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/NormalizationH3.cs b/src/Lucene.Net/Search/Similarities/NormalizationH3.cs index 3efb568..82d8f40 100644 --- a/src/Lucene.Net/Search/Similarities/NormalizationH3.cs +++ b/src/Lucene.Net/Search/Similarities/NormalizationH3.cs @@ -21,6 +21,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Dirichlet Priors normalization + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -31,7 +32,7 @@ namespace Lucene.Net.Search.Similarities private readonly float mu; /// <summary> - /// Calls <seealso cref="#NormalizationH3(float) NormalizationH3(800)"/> + /// Calls <see cref="T:NormalizationH3(800)"/> /// </summary> public NormalizationH3() : this(800F) @@ -39,8 +40,8 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Creates NormalizationH3 with the supplied parameter <code>μ</code>. </summary> - /// <param name="mu"> smoothing parameter <code>μ</code> </param> + /// Creates <see cref="NormalizationH3"/> with the supplied parameter <c>μ</c>. </summary> + /// <param name="mu"> smoothing parameter <c>μ</c> </param> public NormalizationH3(float mu) { this.mu = mu; @@ -57,8 +58,8 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Returns the parameter <code>μ</code> </summary> - /// <seealso cref= #NormalizationH3(float) </seealso> + /// Returns the parameter <c>μ</c> </summary> + /// <seealso cref="NormalizationH3(float)"/> public virtual float Mu { get http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/NormalizationZ.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/NormalizationZ.cs b/src/Lucene.Net/Search/Similarities/NormalizationZ.cs index d8d5df8..4eef520 100644 --- a/src/Lucene.Net/Search/Similarities/NormalizationZ.cs +++ b/src/Lucene.Net/Search/Similarities/NormalizationZ.cs @@ -21,6 +21,7 @@ namespace Lucene.Net.Search.Similarities /// <summary> /// Pareto-Zipf Normalization + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -31,7 +32,7 @@ namespace Lucene.Net.Search.Similarities internal readonly float z; /// <summary> - /// Calls <seealso cref="#NormalizationZ(float) NormalizationZ(0.3)"/> + /// Calls <see cref="T:NormalizationZ(0.3)"/> /// </summary> public NormalizationZ() : this(0.30F) @@ -39,8 +40,8 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Creates NormalizationZ with the supplied parameter <code>z</code>. </summary> - /// <param name="z"> represents <code>A/(A+1)</code> where <code>A</code> + /// Creates <see cref="NormalizationZ"/> with the supplied parameter <paramref name="z"/>. </summary> + /// <param name="z"> represents <c>A/(A+1)</c> where <c>A</c> /// measures the specificity of the language. </param> public NormalizationZ(float z) { @@ -58,8 +59,8 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Returns the parameter <code>z</code> </summary> - /// <seealso cref= #NormalizationZ(float) </seealso> + /// Returns the parameter <c>z</c> </summary> + /// <seealso cref="NormalizationZ(float)"/> public virtual float Z { get http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2a1541c1/src/Lucene.Net/Search/Similarities/PerFieldSimilarityWrapper.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Search/Similarities/PerFieldSimilarityWrapper.cs b/src/Lucene.Net/Search/Similarities/PerFieldSimilarityWrapper.cs index 7197ba9..27d327b 100644 --- a/src/Lucene.Net/Search/Similarities/PerFieldSimilarityWrapper.cs +++ b/src/Lucene.Net/Search/Similarities/PerFieldSimilarityWrapper.cs @@ -23,11 +23,11 @@ namespace Lucene.Net.Search.Similarities using FieldInvertState = Lucene.Net.Index.FieldInvertState; /// <summary> - /// Provides the ability to use a different <seealso cref="Similarity"/> for different fields. - /// <p> - /// Subclasses should implement <seealso cref="#get(String)"/> to return an appropriate - /// Similarity (for example, using field-specific parameter values) for the field. - /// + /// Provides the ability to use a different <see cref="Similarity"/> for different fields. + /// <para/> + /// Subclasses should implement <see cref="Get(string)"/> to return an appropriate + /// <see cref="Similarity"/> (for example, using field-specific parameter values) for the field. + /// <para/> /// @lucene.experimental /// </summary> #if FEATURE_SERIALIZABLE @@ -63,7 +63,7 @@ namespace Lucene.Net.Search.Similarities } /// <summary> - /// Returns a <seealso cref="Similarity"/> for scoring a field. + /// Returns a <see cref="Similarity"/> for scoring a field. /// </summary> public abstract Similarity Get(string name);
