You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2017/06/06 00:11:35 UTC
[02/48] lucenenet git commit: Lucene.Net.Search.Similarities: Fixed
up documentation comments
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 <sh...@shadstorhaug.com>
Authored: Fri Jun 2 23:43:49 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
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);