lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [02/48] lucenenet git commit: Lucene.Net.Search.Similarities: Fixed up documentation comments
Date Tue, 06 Jun 2017 00:11:35 GMT
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 <shad@shadstorhaug.com>
Authored: Fri Jun 2 23:43:49 2017 +0700
Committer: Shad Storhaug <shad@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>
-    /// &nbsp;<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&eacute;phane Clinchant and Eric Gaussier. 2010. Information-based
+    /// in St&#201;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) = &sum;
+    /// <para>The retrieval function is of the form <em>RSV(q, d) = &#8721;
     /// -x<sup>q</sup><sub>w</sub> log Prob(X<sub>w</sub> &gt;=
-    /// t<sup>d</sup><sub>w</sub> | &lambda;<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>&lambda;<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> | &#955;<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>&#955;<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"/>: &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"/>: &#955;<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 (&lambda;<sub>w</sub>)</em> parameter. </summary>
+        /// The <em>lambda (&#955;<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 &lambda;<sub>w</sub> parameter </param>
+        /// <param name="lambda"> distribution's &#955;<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 &lt;distribution&gt; &lt;lambda&gt;&lt;normalization&gt;</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 &mu; parameter. </summary>
+        /// The &#956; parameter. </summary>
         private readonly float mu;
 
         /// <summary>
-        /// Instantiates the similarity with the provided &mu; parameter. </summary>
+        /// Instantiates the similarity with the provided &#956; 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 &mu; parameter. </summary>
+        /// Instantiates the similarity with the provided &#956; parameter. </summary>
         public LMDirichletSimilarity(float mu)
         {
             this.mu = mu;
         }
 
         /// <summary>
-        /// Instantiates the similarity with the default &mu; value of 2000. </summary>
+        /// Instantiates the similarity with the default &#956; value of 2000. </summary>
         public LMDirichletSimilarity(ICollectionModel collectionModel)
             : this(collectionModel, 2000)
         {
         }
 
         /// <summary>
-        /// Instantiates the similarity with the default &mu; value of 2000. </summary>
+        /// Instantiates the similarity with the default &#956; value of 2000. </summary>
         public LMDirichletSimilarity()
             : this(2000)
         {
@@ -97,7 +97,7 @@ namespace Lucene.Net.Search.Similarities
         }
 
         /// <summary>
-        /// Returns the &mu; parameter. </summary>
+        /// Returns the &#956; 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, &lambda;. According to said paper, the
+    /// <para>The model has a single parameter, &#955;. 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 &lambda; parameter. </summary>
+        /// The &#955; parameter. </summary>
         private readonly float lambda;
 
         /// <summary>
-        /// Instantiates with the specified collectionModel and &lambda; parameter. </summary>
+        /// Instantiates with the specified <paramref name="collectionModel"/> and &#955; parameter. </summary>
         public LMJelinekMercerSimilarity(ICollectionModel collectionModel, float lambda)
             : base(collectionModel)
         {
@@ -51,7 +51,7 @@ namespace Lucene.Net.Search.Similarities
         }
 
         /// <summary>
-        /// Instantiates with the specified &lambda; parameter. </summary>
+        /// Instantiates with the specified &#955; parameter. </summary>
         public LMJelinekMercerSimilarity(float lambda)
         {
             this.lambda = lambda;
@@ -73,7 +73,7 @@ namespace Lucene.Net.Search.Similarities
         }
 
         /// <summary>
-        /// Returns the &lambda; parameter. </summary>
+        /// Returns the &#955; 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 (&lambda;<sub>w</sub>)</em> parameter in information-based
-    /// models. </summary>
-    /// <seealso cref= IBSimilarity
-    /// @lucene.experimental </seealso>
+    /// The <em>lambda (&#955;<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>&mu;</code>. </summary>
-        /// <param name="mu"> smoothing parameter <code>&mu;</code> </param>
+        /// Creates <see cref="NormalizationH3"/> with the supplied parameter <c>&#956;</c>. </summary>
+        /// <param name="mu"> smoothing parameter <c>&#956;</c> </param>
         public NormalizationH3(float mu)
         {
             this.mu = mu;
@@ -57,8 +58,8 @@ namespace Lucene.Net.Search.Similarities
         }
 
         /// <summary>
-        /// Returns the parameter <code>&mu;</code> </summary>
-        /// <seealso cref= #NormalizationH3(float) </seealso>
+        /// Returns the parameter <c>&#956;</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);
 


Mime
View raw message