From 01044c7ac6aa8252d2540445ed1bcc62b12f3522 Mon Sep 17 00:00:00 2001 From: Paul Irwin Date: Thu, 10 Oct 2024 17:11:57 -0600 Subject: [PATCH] Fix 
 formatting in TFIDFSimilarity docs

---
 .../Search/Similarities/TFIDFSimilarity.cs    | 388 +++++++++---------
 1 file changed, 194 insertions(+), 194 deletions(-)

diff --git a/src/Lucene.Net/Search/Similarities/TFIDFSimilarity.cs b/src/Lucene.Net/Search/Similarities/TFIDFSimilarity.cs
index ddfced9e8b..36106a077e 100644
--- a/src/Lucene.Net/Search/Similarities/TFIDFSimilarity.cs
+++ b/src/Lucene.Net/Search/Similarities/TFIDFSimilarity.cs
@@ -95,7 +95,7 @@ namespace Lucene.Net.Search.Similarities
     ///     
     /// 
     /// 
-    /// 
+    ///
     ///
     /// Where V(q) · V(d) is the
     /// dot product
@@ -152,7 +152,7 @@ namespace Lucene.Net.Search.Similarities
     ///
     /// Under the simplifying assumption of a single field in the index,
     /// we get Lucene's Conceptual scoring formula:
-    /// 
+    ///
     /// 
     /// 
     ///     
@@ -280,198 +280,198 @@ namespace Lucene.Net.Search.Similarities
     ///
     ///  where
     /// 
-    ///    
-    ///      
-    ///      tf(t in d)
-    ///      correlates to the term's frequency,
-    ///      defined as the number of times term t appears in the currently scored document d.
-    ///      Documents that have more occurrences of a given term receive a higher score.
-    ///      Note that tf(t in q) is assumed to be 1 and therefore it does not appear in this equation,
-    ///      However if a query contains twice the same term, there will be
-    ///      two term-queries with that same term and hence the computation would still be correct (although
-    ///      not very efficient).
-    ///      The default computation for tf(t in d) in
-    ///      DefaultSimilarity () is:
-    ///
-    ///         
-    ///         
-    ///             
-    ///                 
-    ///                     tf(t in d)   =  
-    ///                 
-    ///                 
-    ///                     frequency½
-    ///                 
-    ///             
-    ///         
-    ///         
-    ///         
-    ///    
-    ///
-    ///    
-    ///      
-    ///      idf(t) stands for Inverse Document Frequency. this value
-    ///      correlates to the inverse of DocFreq
-    ///      (the number of documents in which the term t appears).
-    ///      this means rarer terms give higher contribution to the total score.
-    ///      idf(t) appears for t in both the query and the document,
-    ///      hence it is squared in the equation.
-    ///      The default computation for idf(t) in
-    ///      DefaultSimilarity () is:
-    ///
-    ///         
-    ///         
-    ///             
-    ///                 idf(t)   =  
-    ///                 1 + log (
-    ///                 
-    ///                     
-    ///                         NumDocs
-    ///                         –––––––––
-    ///                         DocFreq+1
-    ///                     
-    ///                 
-    ///                 )
-    ///             
-    ///         
-    ///         
-    /// 
-    ///    
-    ///
-    ///    
-    ///      
-    ///      coord(q,d)
-    ///      is a score factor based on how many of the query terms are found in the specified document.
-    ///      Typically, a document that contains more of the query's terms will receive a higher score
-    ///      than another document with fewer query terms.
-    ///      this is a search time factor computed in
-    ///      coord(q,d) ()
-    ///      by the Similarity in effect at search time.
-    ///      
-    ///    
-    ///
-    ///    
-    ///      
-    ///      queryNorm(q)
-    ///      
-    ///      is a normalizing factor used to make scores between queries comparable.
-    ///      this factor does not affect document ranking (since all ranked documents are multiplied by the same factor),
-    ///      but rather just attempts to make scores from different queries (or even different indexes) comparable.
-    ///      this is a search time factor computed by the Similarity in effect at search time.
-    ///
-    ///      The default computation in
-    ///      DefaultSimilarity ()
-    ///      produces a Euclidean norm:
-    ///      
-    ///      
-    ///      
-    ///         
-    ///             
-    ///                 queryNorm(q)    =  
-    ///                 queryNorm(sumOfSquaredWeights)
-    ///                   =  
-    ///             
-    ///             
-    ///                 
-    ///                     1
-    ///                     ––––––––––––––
-    ///                     sumOfSquaredWeights½
-    ///                 
-    ///             
-    ///         
-    ///      
-    ///      
-    ///
-    ///      The sum of squared weights (of the query terms) is
-    ///      computed by the query  object.
-    ///      For example, a 
-    ///      computes this value as:
-    ///      
-    ///      
-    ///      
-    ///         
-    ///             
-    ///                 sumOfSquaredWeights   =  
-    ///                 q.Boost 2
-    ///                  · 
-    ///              
-    ///             ∑
-    ///             
-    ///                 (
-    ///                 idf(t)  · 
-    ///                 t.Boost
-    ///                 ) 2 
-    ///             
-    ///         
-    ///         
-    ///             
-    ///             t in q
-    ///             
-    ///         
-    ///      
-    ///      where sumOfSquaredWeights is  and
-    ///      q.Boost is 
-    ///      
-    ///    
-    ///
-    ///    
-    ///      
-    ///      t.Boost
-    ///      is a search time boost of term t in the query q as
-    ///      specified in the query text
-    ///      (see query syntax),
-    ///      or as set by application calls to
-    ///      .
-    ///      Notice that there is really no direct API for accessing a boost of one term in a multi term query,
-    ///      but rather multi terms are represented in a query as multi
-    ///       objects,
-    ///      and so the boost of a term in the query is accessible by calling the sub-query
-    ///      .
-    ///      
-    ///    
-    ///
-    ///    
-    ///      
-    ///      norm(t,d) encapsulates a few (indexing time) boost and length factors:
-    ///
-    ///      
-    ///        Field boost - set
-    ///        
-    ///        before adding the field to a document.
-    ///        
-    ///        lengthNorm - computed
-    ///        when the document is added to the index in accordance with the number of tokens
-    ///        of this field in the document, so that shorter fields contribute more to the score.
-    ///        LengthNorm is computed by the  class in effect at indexing.
-    ///        
-    ///      
-    ///      The  method is responsible for
-    ///      combining all of these factors into a single .
-    ///
-    ///      
-    ///      When a document is added to the index, all the above factors are multiplied.
-    ///      If the document has multiple fields with the same name, all their boosts are multiplied together:
-    ///      
-    ///      
-    ///      
-    ///         
-    ///             
-    ///                 norm(t,d)   =  
-    ///                 lengthNorm
-    ///                  · 
-    ///             
-    ///             ∏
-    ///             
-    ///         
-    ///         
-    ///             
-    ///             field f in d named as t
-    ///             
-    ///         
-    ///      
-    ///      Note that search time is too late to modify this norm part of scoring,
-    ///      e.g. by using a different  for search.
-    ///    
+    /// 
+    /// 
+    /// tf(t in d)
+    /// correlates to the term's frequency,
+    /// defined as the number of times term t appears in the currently scored document d.
+    /// Documents that have more occurrences of a given term receive a higher score.
+    /// Note that tf(t in q) is assumed to be 1 and therefore it does not appear in this equation,
+    /// However if a query contains twice the same term, there will be
+    /// two term-queries with that same term and hence the computation would still be correct (although
+    /// not very efficient).
+    /// The default computation for tf(t in d) in
+    /// DefaultSimilarity () is:
+    ///
+    /// 
+    /// 
+    ///     
+    ///         
+    ///             tf(t in d)   =  
+    ///         
+    ///         
+    ///             frequency½
+    ///         
+    ///     
+    /// 
+    /// 
+    ///
+    /// 
+    ///
+    /// 
+    /// 
+    /// idf(t) stands for Inverse Document Frequency. this value
+    /// correlates to the inverse of DocFreq
+    /// (the number of documents in which the term t appears).
+    /// this means rarer terms give higher contribution to the total score.
+    /// idf(t) appears for t in both the query and the document,
+    /// hence it is squared in the equation.
+    /// The default computation for idf(t) in
+    /// DefaultSimilarity () is:
+    ///
+    /// 
+    /// 
+    ///     
+    ///         idf(t)   =  
+    ///         1 + log (
+    ///         
+    ///             
+    ///                 NumDocs
+    ///                 –––––––––
+    ///                 DocFreq+1
+    ///             
+    ///         
+    ///         )
+    ///     
+    /// 
+    /// 
+    ///
+    /// 
+    ///
+    /// 
+    ///   
+    ///   coord(q,d)
+    ///   is a score factor based on how many of the query terms are found in the specified document.
+    ///   Typically, a document that contains more of the query's terms will receive a higher score
+    ///   than another document with fewer query terms.
+    ///   this is a search time factor computed in
+    ///   coord(q,d) ()
+    ///   by the Similarity in effect at search time.
+    ///   
+    /// 
+    ///
+    /// 
+    /// 
+    /// queryNorm(q)
+    /// 
+    /// is a normalizing factor used to make scores between queries comparable.
+    /// this factor does not affect document ranking (since all ranked documents are multiplied by the same factor),
+    /// but rather just attempts to make scores from different queries (or even different indexes) comparable.
+    /// this is a search time factor computed by the Similarity in effect at search time.
+    ///
+    /// The default computation in
+    /// DefaultSimilarity ()
+    /// produces a Euclidean norm:
+    ///
+    /// 
+    /// 
+    ///    
+    ///        
+    ///            queryNorm(q)    =  
+    ///            queryNorm(sumOfSquaredWeights)
+    ///              =  
+    ///        
+    ///        
+    ///            
+    ///                1
+    ///                ––––––––––––––
+    ///                sumOfSquaredWeights½
+    ///            
+    ///        
+    ///    
+    /// 
+    /// 
+    ///
+    /// The sum of squared weights (of the query terms) is
+    /// computed by the query  object.
+    /// For example, a 
+    /// computes this value as:
+    ///
+    /// 
+    /// 
+    ///    
+    ///        
+    ///            sumOfSquaredWeights   =  
+    ///            q.Boost 2
+    ///             · 
+    ///        
+    ///        ∑
+    ///        
+    ///            (
+    ///            idf(t)  · 
+    ///            t.Boost
+    ///            ) 2 
+    ///        
+    ///    
+    ///    
+    ///        
+    ///        t in q
+    ///        
+    ///    
+    /// 
+    /// where sumOfSquaredWeights is  and
+    /// q.Boost is 
+    /// 
+    /// 
+    ///
+    /// 
+    ///   
+    ///   t.Boost
+    ///   is a search time boost of term t in the query q as
+    ///   specified in the query text
+    ///   (see query syntax),
+    ///   or as set by application calls to
+    ///   .
+    ///   Notice that there is really no direct API for accessing a boost of one term in a multi term query,
+    ///   but rather multi terms are represented in a query as multi
+    ///    objects,
+    ///   and so the boost of a term in the query is accessible by calling the sub-query
+    ///   .
+    ///   
+    /// 
+    ///
+    /// 
+    ///   
+    ///   norm(t,d) encapsulates a few (indexing time) boost and length factors:
+    ///
+    ///   
+    ///     Field boost - set
+    ///     
+    ///     before adding the field to a document.
+    ///     
+    ///     lengthNorm - computed
+    ///     when the document is added to the index in accordance with the number of tokens
+    ///     of this field in the document, so that shorter fields contribute more to the score.
+    ///     LengthNorm is computed by the  class in effect at indexing.
+    ///     
+    ///   
+    ///   The  method is responsible for
+    ///   combining all of these factors into a single .
+    ///
+    ///   
+    ///   When a document is added to the index, all the above factors are multiplied.
+    ///   If the document has multiple fields with the same name, all their boosts are multiplied together:
+    ///
+    ///   
+    ///   
+    ///      
+    ///          
+    ///              norm(t,d)   =  
+    ///              lengthNorm
+    ///               · 
+    ///          
+    ///          ∏
+    ///          
+    ///      
+    ///      
+    ///          
+    ///          field f in d named as t
+    ///          
+    ///      
+    ///   
+    ///   Note that search time is too late to modify this norm part of scoring,
+    ///   e.g. by using a different  for search.
+    /// 
     /// 
     /// 
     ///