You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by sy...@apache.org on 2016/10/02 14:35:43 UTC
[25/50] [abbrv] lucenenet git commit: Updated Suggest documentation
links to code elements and made corrections.
Updated Suggest documentation links to code elements and made corrections.
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/9a6f9734
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/9a6f9734
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/9a6f9734
Branch: refs/heads/master
Commit: 9a6f9734347b004bd51b3521294ea779ff905d3f
Parents: 106a905
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Fri Sep 16 23:54:08 2016 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Sun Oct 2 17:44:41 2016 +0700
----------------------------------------------------------------------
.../Spell/DirectSpellChecker.cs | 106 ++++++++++----
.../Spell/HighFrequencyDictionary.cs | 2 +-
.../Spell/JaroWinklerDistance.cs | 12 +-
.../Spell/LevensteinDistance.cs | 3 +-
.../Spell/LuceneLevenshteinDistance.cs | 18 +--
src/Lucene.Net.Suggest/Spell/NGramDistance.cs | 3 +-
.../Spell/PlainTextDictionary.cs | 8 +-
src/Lucene.Net.Suggest/Spell/SpellChecker.cs | 143 ++++++++++---------
src/Lucene.Net.Suggest/Spell/SuggestMode.cs | 2 +-
src/Lucene.Net.Suggest/Spell/SuggestWord.cs | 2 +-
.../Spell/SuggestWordFrequencyComparator.cs | 4 +-
.../Spell/SuggestWordQueue.cs | 5 +-
.../Spell/SuggestWordScoreComparator.cs | 4 +-
.../Spell/WordBreakSpellChecker.cs | 61 ++++----
.../Analyzing/AnalyzingInfixSuggester.cs | 103 ++++++-------
.../Suggest/Analyzing/AnalyzingSuggester.cs | 58 ++++----
.../Suggest/Analyzing/BlendedInfixSuggester.cs | 20 ++-
.../Suggest/Analyzing/FSTUtil.cs | 8 +-
.../Suggest/Analyzing/FreeTextSuggester.cs | 49 ++++---
.../Suggest/Analyzing/FuzzySuggester.cs | 66 ++++-----
.../Suggest/Analyzing/SuggestStopFilter.cs | 21 +--
.../Suggest/BufferedInputIterator.cs | 2 +-
.../Suggest/BufferingTermFreqIteratorWrapper.cs | 2 +-
.../Suggest/DocumentDictionary.cs | 50 +++----
.../Suggest/DocumentValueSourceDictionary.cs | 49 ++++---
.../Suggest/FileDictionary.cs | 52 +++----
.../Suggest/Fst/BytesRefSorter.cs | 14 +-
.../Suggest/Fst/FSTCompletion.cs | 53 +++----
.../Suggest/Fst/FSTCompletionBuilder.cs | 64 ++++-----
.../Suggest/Fst/FSTCompletionLookup.cs | 32 ++---
.../Suggest/Fst/WFSTCompletionLookup.cs | 4 +-
.../Suggest/InMemorySorter.cs | 2 +-
src/Lucene.Net.Suggest/Suggest/InputIterator.cs | 16 +--
.../Suggest/Jaspell/JaspellLookup.cs | 8 +-
.../Suggest/Jaspell/JaspellTernarySearchTrie.cs | 124 ++++++++--------
src/Lucene.Net.Suggest/Suggest/Lookup.cs | 30 ++--
.../Suggest/SortedInputIterator.cs | 5 +-
.../Suggest/SortedTermFreqIteratorWrapper.cs | 6 +-
.../Suggest/Tst/TSTAutocomplete.cs | 4 +-
src/Lucene.Net.Suggest/Suggest/Tst/TSTLookup.cs | 7 +-
40 files changed, 636 insertions(+), 586 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs b/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
index 40ddfdf..1835909 100644
--- a/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
+++ b/src/Lucene.Net.Suggest/Spell/DirectSpellChecker.cs
@@ -29,9 +29,9 @@ namespace Lucene.Net.Search.Spell
/// Simple automaton-based spellchecker.
/// <para>
/// Candidates are presented directly from the term dictionary, based on
- /// Levenshtein distance. This is an alternative to <seealso cref="SpellChecker"/>
+ /// Levenshtein distance. This is an alternative to <see cref="SpellChecker"/>
/// if you are using an edit-distance-like metric such as Levenshtein
- /// or <seealso cref="JaroWinklerDistance"/>.
+ /// or <see cref="JaroWinklerDistance"/>.
/// </para>
/// <para>
/// A practical benefit of this spellchecker is that it requires no additional
@@ -39,15 +39,15 @@ namespace Lucene.Net.Search.Spell
///
/// </para>
/// </summary>
- /// <seealso cref= LevenshteinAutomata </seealso>
- /// <seealso cref= FuzzyTermsEnum
+ /// <seealso cref="LevenshteinAutomata"/>
+ /// <seealso cref="FuzzyTermsEnum"/>
///
- /// @lucene.experimental </seealso>
+ /// @lucene.experimental
public class DirectSpellChecker
{
/// <summary>
/// The default StringDistance, Damerau-Levenshtein distance implemented internally
- /// via <seealso cref="LevenshteinAutomata"/>.
+ /// via <see cref="LevenshteinAutomata"/>.
/// <para>
/// Note: this is the fastest distance metric, because Damerau-Levenshtein is used
/// to draw candidates from the term dictionary: this just re-uses the scoring.
@@ -92,14 +92,19 @@ namespace Lucene.Net.Search.Spell
private IStringDistance distance = INTERNAL_LEVENSHTEIN;
/// <summary>
- /// Creates a DirectSpellChecker with default configuration values </summary>
+ /// Creates a DirectSpellChecker with default configuration values
+ /// </summary>
public DirectSpellChecker()
{
}
/// <summary>
- /// Get the maximum number of Levenshtein edit-distances to draw
- /// candidate terms from.
+ /// Gets or sets the maximum number of Levenshtein edit-distances to draw
+ /// candidate terms from.This value can be 1 or 2. The default is 2.
+ ///
+ /// Note: a large number of spelling errors occur with an edit distance
+ /// of 1, by setting this value to 1 you can increase both performance
+ /// and precision at the cost of recall.
/// </summary>
public virtual int MaxEdits
{
@@ -119,7 +124,10 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Get the minimal number of characters that must match exactly
+ /// Gets or sets the minimal number of characters that must match exactly.
+ ///
+ /// This can improve both performance and accuracy of results,
+ /// as misspellings are commonly not the first character.
/// </summary>
public virtual int MinPrefix
{
@@ -135,7 +143,10 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Get the maximum number of top-N inspections per suggestion
+ /// Get the maximum number of top-N inspections per suggestion.
+ ///
+ /// Increasing this number can improve the accuracy of results, at the cost
+ /// of performance.
/// </summary>
public virtual int MaxInspections
{
@@ -151,7 +162,8 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Get the minimal accuracy from the StringDistance for a match
+ /// Gets or sets the minimal accuracy required (default: 0.5f) from a StringDistance
+ /// for a suggestion match.
/// </summary>
public virtual float Accuracy
{
@@ -167,7 +179,16 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Get the minimal threshold of documents a term must appear for a match
+ /// Gets or sets the minimal threshold of documents a term must appear for a match.
+ /// <p>
+ /// This can improve quality by only suggesting high-frequency terms. Note that
+ /// very high values might decrease performance slightly, by forcing the spellchecker
+ /// to draw more candidates from the term dictionary, but a practical value such
+ /// as <code>1</code> can be very useful towards improving quality.
+ /// <p>
+ /// This can be specified as a relative percentage of documents such as 0.5f,
+ /// or it can be specified as an absolute whole document frequency, such as 4f.
+ /// Absolute document frequencies may not be fractional.
/// </summary>
public virtual float ThresholdFrequency
{
@@ -187,7 +208,11 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Get the minimum length of a query term needed to return suggestions </summary>
+ /// Gets or sets the minimum length of a query term (default: 4) needed to return suggestions.
+ /// <p>
+ /// Very short query terms will often cause only bad suggestions with any distance
+ /// metric.
+ /// </summary>
public virtual int MinQueryLength
{
get
@@ -202,8 +227,16 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Get the maximum threshold of documents a query term can appear in order
- /// to provide suggestions.
+ /// Gets or sets the maximum threshold (default: 0.01f) of documents a query term can
+ /// appear in order to provide suggestions.
+ /// <p>
+ /// Very high-frequency terms are typically spelled correctly. Additionally,
+ /// this can increase performance as it will do no work for the common case
+ /// of correctly-spelled input terms.
+ /// <p>
+ /// This can be specified as a relative percentage of documents such as 0.5f,
+ /// or it can be specified as an absolute whole document frequency, such as 4f.
+ /// Absolute document frequencies may not be fractional.
/// </summary>
public virtual float MaxQueryFrequency
{
@@ -223,7 +256,15 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// true if the spellchecker should lowercase terms </summary>
+ /// True if the spellchecker should lowercase terms (default: true)
+ /// <p>
+ /// This is a convenience method, if your index field has more complicated
+ /// analysis (such as StandardTokenizer removing punctuation), its probably
+ /// better to turn this off, and instead run your query terms through your
+ /// Analyzer first.
+ /// <p>
+ /// If this option is not on, case differences count as an edit!
+ /// </summary>
public virtual bool LowerCaseTerms
{
get
@@ -238,7 +279,8 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Get the current comparator in use.
+ /// Gets or sets the comparator for sorting suggestions.
+ /// The default is <see cref="SuggestWordQueue.DEFAULT_COMPARATOR"/>
/// </summary>
public virtual IComparer<SuggestWord> Comparator
{
@@ -254,7 +296,14 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Get the string distance metric in use.
+ /// Gets or sets the string distance metric.
+ /// The default is <see cref="INTERNAL_LEVENSHTEIN"/>.
+ /// <p>
+ /// Note: because this spellchecker draws its candidates from the term
+ /// dictionary using Damerau-Levenshtein, it works best with an edit-distance-like
+ /// string metric. If you use a different metric than the default,
+ /// you might want to consider increasing <see cref="MaxInspections"/>
+ /// to draw more candidates for your metric to rank.
/// </summary>
public virtual IStringDistance Distance
{
@@ -270,8 +319,8 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Calls {@link #suggestSimilar(Term, int, IndexReader, SuggestMode)
- /// suggestSimilar(term, numSug, ir, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX)}
+ /// Calls <see cref="SuggestSimilar(Term, int, IndexReader, SuggestMode)"/>
+ /// SuggestSimilar(term, numSug, ir, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX)
/// </summary>
public virtual SuggestWord[] SuggestSimilar(Term term, int numSug, IndexReader ir)
{
@@ -279,9 +328,8 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Calls {@link #suggestSimilar(Term, int, IndexReader, SuggestMode, float)
- /// suggestSimilar(term, numSug, ir, suggestMode, this.accuracy)}
- ///
+ /// Calls <see cref="SuggestSimilar(Term, int, IndexReader, SuggestMode, float)"/>
+ /// SuggestSimilar(term, numSug, ir, suggestMode, this.accuracy)
/// </summary>
public virtual SuggestWord[] SuggestSimilar(Term term, int numSug, IndexReader ir, SuggestMode suggestMode)
{
@@ -291,10 +339,10 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Suggest similar words.
///
- /// <para>Unlike <seealso cref="SpellChecker"/>, the similarity used to fetch the most
+ /// <para>
+ /// Unlike <see cref="SpellChecker"/>, the similarity used to fetch the most
/// relevant terms is an edit distance, therefore typically a low value
/// for numSug will work very well.
- ///
/// </para>
/// </summary>
/// <param name="term"> Term you want to spell check on </param>
@@ -303,7 +351,7 @@ namespace Lucene.Net.Search.Spell
/// <param name="suggestMode"> specifies when to return suggested words </param>
/// <param name="accuracy"> return only suggested words that match with this similarity </param>
/// <returns> sorted list of the suggested words according to the comparator </returns>
- /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+ /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
public virtual SuggestWord[] SuggestSimilar(Term term, int numSug, IndexReader ir, SuggestMode suggestMode, float accuracy)
{
CharsRef spare = new CharsRef();
@@ -402,7 +450,7 @@ namespace Lucene.Net.Search.Spell
/// <param name="accuracy"> The minimum accuracy a suggested spelling correction needs to have in order to be included </param>
/// <param name="spare"> a chars scratch </param>
/// <returns> a collection of spelling corrections sorted by <code>ScoreTerm</code>'s natural order. </returns>
- /// <exception cref="IOException"> If I/O related errors occur </exception>
+ /// <exception cref="System.IO.IOException"> If I/O related errors occur </exception>
protected internal virtual IEnumerable<ScoreTerm> SuggestSimilar(Term term, int numSug, IndexReader ir, int docfreq, int editDistance, float accuracy, CharsRef spare)
{
@@ -481,7 +529,7 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Holds a spelling correction for internal usage inside <seealso cref="DirectSpellChecker"/>.
+ /// Holds a spelling correction for internal usage inside <see cref="DirectSpellChecker"/>.
/// </summary>
protected internal class ScoreTerm : IComparable<ScoreTerm>
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs b/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs
index 6b84a47..9a7e243 100644
--- a/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs
+++ b/src/Lucene.Net.Suggest/Spell/HighFrequencyDictionary.cs
@@ -29,7 +29,7 @@ namespace Lucene.Net.Search.Spell
/// Threshold is a value in [0..1] representing the minimum
/// number of documents (of the total) where a term should appear.
///
- /// Based on LuceneDictionary.
+ /// Based on <see cref="LuceneDictionary"/>.
/// </summary>
public class HighFrequencyDictionary : IDictionary
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs b/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
index e43a64e..c17f7cd 100644
--- a/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/JaroWinklerDistance.cs
@@ -22,10 +22,8 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Similarity measure for short strings such as person names.
- /// <para>
- /// </para>
+ /// See <a href="http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance">http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance</a>
/// </summary>
- /// <seealso cref= <a href="http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance">http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance</a> </seealso>
public class JaroWinklerDistance : IStringDistance
{
@@ -34,7 +32,7 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Creates a new distance metric with the default threshold
/// for the Jaro Winkler bonus (0.7) </summary>
- /// <seealso cref= #setThreshold(float) </seealso>
+ /// <seealso cref="Threshold"/>
public JaroWinklerDistance()
{
}
@@ -126,9 +124,9 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Sets the threshold used to determine when Winkler bonus should be used.
- /// Set to a negative value to get the Jaro distance. </summary>
- /// <param name="threshold"> the new value of the threshold </param>
+ /// Gets or sets the threshold used to determine when Winkler bonus should be used.
+ /// The default value is 0.7. Set to a negative value to get the Jaro distance.
+ /// </summary>
public virtual float Threshold
{
set
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs b/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs
index 4a1e281..65e3b12 100644
--- a/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/LevensteinDistance.cs
@@ -22,11 +22,12 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Levenstein edit distance class.
/// </summary>
+ // LUCENENET NOTE: This class is misspelled: It should be Levenshtein
public sealed class LevensteinDistance : IStringDistance
{
/// <summary>
- /// Optimized to run a bit faster than the static getDistance().
+ /// Optimized to run a bit faster than the static GetDistance().
/// In one benchmark times were 5.3sec using ctr vs 8.5sec w/ static method, thus 37% faster.
/// </summary>
public LevensteinDistance()
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs b/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
index bce0cc2..5ee47ea 100644
--- a/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
@@ -26,15 +26,15 @@ namespace Lucene.Net.Search.Spell
/// way as Lucene's FuzzyTermsEnum with the transpositions option enabled.
///
/// Notes:
- /// <ul>
- /// <li> This metric treats full unicode codepoints as characters
- /// <li> This metric scales raw edit distances into a floating point score
- /// based upon the shortest of the two terms
- /// <li> Transpositions of two adjacent codepoints are treated as primitive
- /// edits.
- /// <li> Edits are applied in parallel: for example, "ab" and "bca" have
- /// distance 3.
- /// </ul>
+ /// <list type="bullet">
+ /// <item> This metric treats full unicode codepoints as characters</item>
+ /// <item> This metric scales raw edit distances into a floating point score
+ /// based upon the shortest of the two terms</item>
+ /// <item> Transpositions of two adjacent codepoints are treated as primitive
+ /// edits.</item>
+ /// <item> Edits are applied in parallel: for example, "ab" and "bca" have
+ /// distance 3.</item>
+ /// </list>
///
/// NOTE: this class is not particularly efficient. It is only intended
/// for merging results from multiple DirectSpellCheckers.
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/NGramDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/NGramDistance.cs b/src/Lucene.Net.Suggest/Spell/NGramDistance.cs
index b133fa4..7d52afe 100644
--- a/src/Lucene.Net.Suggest/Spell/NGramDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/NGramDistance.cs
@@ -24,14 +24,13 @@ namespace Lucene.Net.Search.Spell
/// "N-gram similarity and distance". Proceedings of the Twelfth International
/// Conference on String Processing and Information Retrieval (SPIRE 2005), pp. 115-126,
/// Buenos Aires, Argentina, November 2005.
- /// http://www.cs.ualberta.ca/~kondrak/papers/spire05.pdf
+ /// <a href="http://www.cs.ualberta.ca/~kondrak/papers/spire05.pdf">http://www.cs.ualberta.ca/~kondrak/papers/spire05.pdf</a>
///
/// This implementation uses the position-based optimization to compute partial
/// matches of n-gram sub-strings and adds a null-character prefix of size n-1
/// so that the first character is contained in the same number of n-grams as
/// a middle character. Null-character prefix matches are discounted so that
/// strings with no matching characters will return a distance of 0.
- ///
/// </summary>
public class NGramDistance : IStringDistance
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs b/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs
index 7e85d36..c25679e 100644
--- a/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs
+++ b/src/Lucene.Net.Suggest/Spell/PlainTextDictionary.cs
@@ -26,10 +26,10 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Dictionary represented by a text file.
///
- /// <p/>Format allowed: 1 word per line:<br/>
- /// word1<br/>
- /// word2<br/>
- /// word3<br/>
+ /// <para/>Format allowed: 1 word per line:<para/>
+ /// word1<para/>
+ /// word2<para/>
+ /// word3<para/>
/// </summary>
public class PlainTextDictionary : IDictionary
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SpellChecker.cs b/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
index b88cef1..524a40b 100644
--- a/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
+++ b/src/Lucene.Net.Suggest/Spell/SpellChecker.cs
@@ -32,17 +32,16 @@ namespace Lucene.Net.Search.Spell
/// (initially inspired by the David Spencer code).
/// </para>
///
- /// <para>Example Usage:
+ /// <para>Example Usage (C#):
///
- /// <pre class="prettyprint">
+ /// <code>
/// SpellChecker spellchecker = new SpellChecker(spellIndexDirectory);
/// // To index a field of a user index:
- /// spellchecker.indexDictionary(new LuceneDictionary(my_lucene_reader, a_field));
+ /// spellchecker.IndexDictionary(new LuceneDictionary(my_lucene_reader, a_field));
/// // To index a file containing words:
- /// spellchecker.indexDictionary(new PlainTextDictionary(new File("myfile.txt")));
- /// String[] suggestions = spellchecker.suggestSimilar("misspelt", 5);
- /// </pre>
- ///
+ /// spellchecker.IndexDictionary(new PlainTextDictionary(new FileInfo("myfile.txt")));
+ /// string[] suggestions = spellchecker.SuggestSimilar("misspelt", 5);
+ /// </code>
///
/// </para>
/// </summary>
@@ -50,7 +49,8 @@ namespace Lucene.Net.Search.Spell
{
/// <summary>
- /// The default minimum score to use, if not specified by calling <seealso cref="#setAccuracy(float)"/> .
+ /// The default minimum score to use, if not specified by setting <see cref="Accuracy"/>
+ /// or overriding with <see cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/> .
/// </summary>
public const float DEFAULT_ACCURACY = 0.5f;
@@ -62,7 +62,7 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// the spell index
/// </summary>
- // don't modify the directory directly - see #swapSearcher()
+ // don't modify the directory directly - see SwapSearcher()
// TODO: why is this package private?
internal Directory spellIndex;
/// <summary>
@@ -71,8 +71,8 @@ namespace Lucene.Net.Search.Spell
private float bStart = 2.0f;
private float bEnd = 1.0f;
- // don't use this searcher directly - see #swapSearcher()
+ // don't use this searcher directly - see SwapSearcher()
private IndexSearcher searcher;
/// <summary>
@@ -100,20 +100,20 @@ namespace Lucene.Net.Search.Spell
/// Use the given directory as a spell checker index. The directory
/// is created if it doesn't exist yet. </summary>
/// <param name="spellIndex"> the spell index directory </param>
- /// <param name="sd"> the <seealso cref="StringDistance"/> measurement to use </param>
- /// <exception cref="IOException"> if Spellchecker can not open the directory </exception>
+ /// <param name="sd"> the <see cref="StringDistance"/> measurement to use </param>
+ /// <exception cref="System.IO.IOException"> if Spellchecker can not open the directory </exception>
public SpellChecker(Directory spellIndex, IStringDistance sd)
: this(spellIndex, sd, SuggestWordQueue.DEFAULT_COMPARATOR)
{
}
/// <summary>
/// Use the given directory as a spell checker index with a
- /// <seealso cref="LevensteinDistance"/> as the default <seealso cref="StringDistance"/>. The
+ /// <see cref="LevensteinDistance"/> as the default <see cref="T:StringDistance"/>. The
/// directory is created if it doesn't exist yet.
/// </summary>
/// <param name="spellIndex">
/// the spell index directory </param>
- /// <exception cref="IOException">
+ /// <exception cref="System.IO.IOException">
/// if spellchecker can not open the directory </exception>
public SpellChecker(Directory spellIndex)
: this(spellIndex, new LevensteinDistance())
@@ -121,12 +121,12 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Use the given directory as a spell checker index with the given <seealso cref="Lucene.Net.Search.Spell.IStringDistance"/> measure
- /// and the given <seealso cref="System.Collections.Generic.IComparer{T}"/> for sorting the results. </summary>
+ /// Use the given directory as a spell checker index with the given <see cref="IStringDistance"/> measure
+ /// and the given <see cref="System.Collections.Generic.IComparer{T}"/> for sorting the results. </summary>
/// <param name="spellIndex"> The spelling index </param>
/// <param name="sd"> The distance </param>
/// <param name="comparator"> The comparator </param>
- /// <exception cref="IOException"> if there is a problem opening the index </exception>
+ /// <exception cref="System.IO.IOException"> if there is a problem opening the index </exception>
public SpellChecker(Directory spellIndex, IStringDistance sd, IComparer<SuggestWord> comparator)
{
SpellIndex = spellIndex;
@@ -135,7 +135,7 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Use a different index as the spell checker index or re-open
+ /// Sets a different index as the spell checker index or re-open
/// the existing index if <code>spellIndex</code> is the same value
/// as given in the constructor. </summary>
/// <param name="spellIndexDir"> the spell directory to use </param>
@@ -163,8 +163,8 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Sets the <seealso cref="java.util.Comparator"/> for the <seealso cref="SuggestWordQueue"/>. </summary>
- /// <param name="comparator"> the comparator </param>
+ /// Gets or sets the <see cref="IComparer{T}"/> for the <see cref="SuggestWordQueue"/>.
+ /// </summary>
public virtual IComparer<SuggestWord> Comparator
{
set
@@ -179,11 +179,9 @@ namespace Lucene.Net.Search.Spell
/// <summary>
- /// Sets the <seealso cref="StringDistance"/> implementation for this
- /// <seealso cref="SpellChecker"/> instance.
+ /// Gets or sets the <see cref="T:StringDistance"/> implementation for this
+ /// <see cref="SpellChecker"/> instance.
/// </summary>
- /// <param name="sd"> the <seealso cref="StringDistance"/> implementation for this
- /// <seealso cref="SpellChecker"/> instance </param>
public virtual IStringDistance StringDistance
{
set
@@ -197,8 +195,11 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Sets the accuracy 0 < minScore < 1; default <seealso cref="#DEFAULT_ACCURACY"/> </summary>
- /// <param name="acc"> The new accuracy </param>
+ /// Gets or sets the accuracy (minimum score) to be used, unless overridden in
+ /// <see cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/>,
+ /// to decide whether a suggestion is included or not.
+ /// Sets the accuracy 0 < minScore < 1; default <see cref="DEFAULT_ACCURACY"/>
+ /// </summary>
public virtual float Accuracy
{
set
@@ -214,25 +215,25 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Suggest similar words.
- ///
- /// <para>As the Lucene similarity that is used to fetch the most relevant n-grammed terms
+ /// <para>
+ /// As the Lucene similarity that is used to fetch the most relevant n-grammed terms
/// is not the same as the edit distance strategy used to calculate the best
/// matching spell-checked word from the hits that Lucene found, one usually has
/// to retrieve a couple of numSug's in order to get the true best match.
- ///
/// </para>
- /// <para>I.e. if numSug == 1, don't count on that suggestion being the best one.
+ /// <para>
+ /// I.e. if numSug == 1, don't count on that suggestion being the best one.
/// Thus, you should set this value to <b>at least</b> 5 for a good suggestion.
- ///
/// </para>
/// </summary>
/// <param name="word"> the word you want a spell check done on </param>
/// <param name="numSug"> the number of suggested words </param>
- /// <exception cref="IOException"> if the underlying index throws an <seealso cref="IOException"/> </exception>
- /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
- /// <returns> String[]
- /// </returns>
- /// <seealso cref= #suggestSimilar(String, int, IndexReader, String, SuggestMode, float) </seealso>
+ /// <exception cref="System.IO.IOException"> if the underlying index throws an <see cref="IOException"/> </exception>
+ /// <exception cref="AlreadyClosedException"> if the Spellchecker is already disposed </exception>
+ /// <returns>string[] the sorted list of the suggest words with these 2 criteria:
+ /// first criteria: the edit distance, second criteria (only if restricted mode): the popularity
+ /// of the suggest words in the field of the user index</returns>
+ /// <seealso cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/>
public virtual string[] SuggestSimilar(string word, int numSug)
{
return this.SuggestSimilar(word, numSug, null, null, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX);
@@ -240,34 +241,34 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Suggest similar words.
- ///
- /// <para>As the Lucene similarity that is used to fetch the most relevant n-grammed terms
+ /// <para>
+ /// As the Lucene similarity that is used to fetch the most relevant n-grammed terms
/// is not the same as the edit distance strategy used to calculate the best
/// matching spell-checked word from the hits that Lucene found, one usually has
/// to retrieve a couple of numSug's in order to get the true best match.
- ///
/// </para>
- /// <para>I.e. if numSug == 1, don't count on that suggestion being the best one.
+ /// <para>
+ /// I.e. if numSug == 1, don't count on that suggestion being the best one.
/// Thus, you should set this value to <b>at least</b> 5 for a good suggestion.
- ///
/// </para>
/// </summary>
/// <param name="word"> the word you want a spell check done on </param>
/// <param name="numSug"> the number of suggested words </param>
/// <param name="accuracy"> The minimum score a suggestion must have in order to qualify for inclusion in the results </param>
- /// <exception cref="IOException"> if the underlying index throws an <seealso cref="IOException"/> </exception>
- /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
- /// <returns> String[]
- /// </returns>
- /// <seealso cref= #suggestSimilar(String, int, IndexReader, String, SuggestMode, float) </seealso>
+ /// <exception cref="System.IO.IOException"> if the underlying index throws an <see cref="IOException"/> </exception>
+ /// <exception cref="AlreadyClosedException"> if the Spellchecker is already disposed </exception>
+ /// <returns>string[] the sorted list of the suggest words with these 2 criteria:
+ /// first criteria: the edit distance, second criteria (only if restricted mode): the popularity
+ /// of the suggest words in the field of the user index</returns>
+ /// <seealso cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/>
public virtual string[] SuggestSimilar(string word, int numSug, float accuracy)
{
return this.SuggestSimilar(word, numSug, null, null, SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX, accuracy);
}
/// <summary>
- /// Calls {@link #suggestSimilar(String, int, IndexReader, String, SuggestMode, float)
- /// suggestSimilar(word, numSug, ir, suggestMode, field, this.accuracy)}
+ /// Calls <see cref="SuggestSimilar(string, int, IndexReader, string, SuggestMode, float)"/>
+ /// SuggestSimilar(word, numSug, ir, suggestMode, field, this.accuracy)
///
/// </summary>
public virtual string[] SuggestSimilar(string word, int numSug, IndexReader ir, string field, SuggestMode suggestMode)
@@ -277,16 +278,15 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Suggest similar words (optionally restricted to a field of an index).
- ///
- /// <para>As the Lucene similarity that is used to fetch the most relevant n-grammed terms
+ /// <para>
+ /// As the Lucene similarity that is used to fetch the most relevant n-grammed terms
/// is not the same as the edit distance strategy used to calculate the best
/// matching spell-checked word from the hits that Lucene found, one usually has
/// to retrieve a couple of numSug's in order to get the true best match.
- ///
/// </para>
- /// <para>I.e. if numSug == 1, don't count on that suggestion being the best one.
+ /// <para>
+ /// I.e. if numSug == 1, don't count on that suggestion being the best one.
/// Thus, you should set this value to <b>at least</b> 5 for a good suggestion.
- ///
/// </para>
/// </summary>
/// <param name="word"> the word you want a spell check done on </param>
@@ -297,9 +297,9 @@ namespace Lucene.Net.Search.Spell
/// <param name="suggestMode">
/// (NOTE: if indexReader==null and/or field==null, then this is overridden with SuggestMode.SUGGEST_ALWAYS) </param>
/// <param name="accuracy"> The minimum score a suggestion must have in order to qualify for inclusion in the results </param>
- /// <exception cref="IOException"> if the underlying index throws an <seealso cref="IOException"/> </exception>
- /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
- /// <returns> String[] the sorted list of the suggest words with these 2 criteria:
+ /// <exception cref="System.IO.IOException"> if the underlying index throws an <see cref="IOException"/> </exception>
+ /// <exception cref="AlreadyClosedException"> if the <see cref="Spellchecker"/> is already disposed </exception>
+ /// <returns> string[] the sorted list of the suggest words with these 2 criteria:
/// first criteria: the edit distance, second criteria (only if restricted mode): the popularity
/// of the suggest words in the field of the user index
/// </returns>
@@ -457,7 +457,7 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Removes all terms from the spell check index. </summary>
- /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+ /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
/// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
public virtual void ClearIndex()
{
@@ -474,8 +474,8 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Check whether the word exists in the index. </summary>
/// <param name="word"> word to check </param>
- /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
- /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
+ /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
+ /// <exception cref="AlreadyClosedException"> if the <see cref="Spellchecker"/> is already disposed </exception>
/// <returns> true if the word exists in the index </returns>
public virtual bool Exist(string word)
{
@@ -494,12 +494,13 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Indexes the data from the given <seealso cref="IDictionary"/>. </summary>
+ /// Indexes the data from the given <see cref="IDictionary"/>. </summary>
/// <param name="dict"> Dictionary to index </param>
- /// <param name="config"> <seealso cref="IndexWriterConfig"/> to use </param>
+ /// <param name="config"> <see cref="IndexWriterConfig"/> to use </param>
/// <param name="fullMerge"> whether or not the spellcheck index should be fully merged </param>
- /// <exception cref="AlreadyClosedException"> if the Spellchecker is already closed </exception>
- /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+ /// <exception cref="AlreadyClosedException"> if the <see cref="Spellchecker"/> is already disposed </exception>
+ /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
+ // LUCENENET TODO: Replace all usage of AlreadyClosedException with System.ObjectDisposedException
public void IndexDictionary(IDictionary dict, IndexWriterConfig config, bool fullMerge)
{
lock (modifyCurrentIndexLock)
@@ -673,9 +674,9 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Close the IndexSearcher used by this SpellChecker </summary>
- /// <exception cref="IOException"> if the close operation causes an <seealso cref="IOException"/> </exception>
- /// <exception cref="AlreadyClosedException"> if the <seealso cref="SpellChecker"/> is already closed </exception>
+ /// Dispose the underlying IndexSearcher used by this SpellChecker </summary>
+ /// <exception cref="System.IO.IOException"> if the close operation causes an <see cref="IOException"/> </exception>
+ /// <exception cref="AlreadyClosedException"> if the <see cref="SpellChecker"/> is already disposed </exception>
public void Dispose()
{
lock (searcherLock)
@@ -719,7 +720,7 @@ namespace Lucene.Net.Search.Spell
/// Creates a new read-only IndexSearcher </summary>
/// <param name="dir"> the directory used to open the searcher </param>
/// <returns> a new read-only IndexSearcher </returns>
- /// <exception cref="IOException"> f there is a low-level IO error </exception>
+ /// <exception cref="System.IO.IOException"> f there is a low-level IO error </exception>
// for testing purposes
internal virtual IndexSearcher CreateSearcher(Directory dir)
{
@@ -727,11 +728,11 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Returns <code>true</code> if and only if the <seealso cref="SpellChecker"/> is
- /// disposed, otherwise <code>false</code>.
+ /// Returns <c>true</c> if and only if the <see cref="SpellChecker"/> is
+ /// disposed, otherwise <c>false</c>.
/// </summary>
- /// <returns> <code>true</code> if and only if the <seealso cref="SpellChecker"/> is
- /// disposed, otherwise <code>false</code>. </returns>
+ /// <returns> <c>true</c> if and only if the <see cref="SpellChecker"/> is
+ /// disposed, otherwise <c>false</c>. </returns>
internal virtual bool IsDisposed
{
get
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestMode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestMode.cs b/src/Lucene.Net.Suggest/Spell/SuggestMode.cs
index fdda563..a782b41 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestMode.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestMode.cs
@@ -37,7 +37,7 @@
/// <summary>
/// Always attempt to offer suggestions (however, other parameters may limit
/// suggestions. For example, see
- /// <seealso cref="DirectSpellChecker#setMaxQueryFrequency(float)"/> ).
+ /// <see cref="DirectSpellChecker.MaxQueryFrequency"/> ).
/// </summary>
SUGGEST_ALWAYS
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestWord.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestWord.cs b/src/Lucene.Net.Suggest/Spell/SuggestWord.cs
index 1576a7b..ef5de3e 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestWord.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestWord.cs
@@ -18,7 +18,7 @@
*/
/// <summary>
- /// SuggestWord, used in suggestSimilar method in SpellChecker class.
+ /// SuggestWord, used in suggestSimilar method in <see cref="SpellChecker"/> class.
/// <p/>
/// Default sort is first by score, then by frequency.
/// </summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs b/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs
index 252233f..3ddf3e9 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestWordFrequencyComparator.cs
@@ -27,8 +27,8 @@ namespace Lucene.Net.Search.Spell
{
/// <summary>
- /// Creates a new comparator that will compare by <seealso cref="SuggestWord#freq"/>,
- /// then by <seealso cref="SuggestWord#score"/>, then by <seealso cref="SuggestWord#string"/>.
+ /// Creates a new comparator that will compare by <see cref="SuggestWord.Freq"/>,
+ /// then by <see cref="SuggestWord.Score"/>, then by <see cref="SuggestWord.String"/>.
/// </summary>
public SuggestWordFrequencyComparator()
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs b/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs
index 3a0ebc9..ea9311f 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestWordQueue.cs
@@ -25,19 +25,18 @@ namespace Lucene.Net.Search.Spell
/// </summary>
/// <seealso cref="SuggestWordScoreComparator"/>
/// <seealso cref="SuggestWordFrequencyComparator"/>
- /// </seealso>
public sealed class SuggestWordQueue : PriorityQueue<SuggestWord>
{
/// <summary>
/// Default comparator: score then frequency. </summary>
- /// <seealso cref= SuggestWordScoreComparator </seealso>
+ /// <seealso cref="SuggestWordScoreComparator"/>
public static readonly IComparer<SuggestWord> DEFAULT_COMPARATOR = new SuggestWordScoreComparator();
private readonly IComparer<SuggestWord> comparator;
/// <summary>
- /// Use the <seealso cref="#DEFAULT_COMPARATOR"/> </summary>
+ /// Use the <see cref="DEFAULT_COMPARATOR"/> </summary>
/// <param name="size"> The size of the queue </param>
public SuggestWordQueue(int size)
: base(size)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs b/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs
index 3d875db..b444e8f 100644
--- a/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs
+++ b/src/Lucene.Net.Suggest/Spell/SuggestWordScoreComparator.cs
@@ -27,8 +27,8 @@ namespace Lucene.Net.Search.Spell
{
/// <summary>
- /// Creates a new comparator that will compare by <seealso cref="SuggestWord#score"/>,
- /// then by <seealso cref="SuggestWord#freq"/>, then by <seealso cref="SuggestWord#string"/>.
+ /// Creates a new comparator that will compare by <see cref="SuggestWord.Score"/>,
+ /// then by <see cref="SuggestWord.Freq"/>, then by <see cref="SuggestWord.String"/>.
/// </summary>
public SuggestWordScoreComparator()
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs b/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs
index fb79975..d1d1e0e 100644
--- a/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs
+++ b/src/Lucene.Net.Suggest/Spell/WordBreakSpellChecker.cs
@@ -42,19 +42,17 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// Creates a new spellchecker with default configuration values </summary>
- /// <seealso cref= #setMaxChanges(int) </seealso>
- /// <seealso cref= #setMaxCombineWordLength(int) </seealso>
- /// <seealso cref= #setMaxEvaluations(int) </seealso>
- /// <seealso cref= #setMinBreakWordLength(int) </seealso>
- /// <seealso cref= #setMinSuggestionFrequency(int) </seealso>
+ /// <seealso cref="MaxChanges"/>
+ /// <seealso cref="MaxCombineWordLength"/>
+ /// <seealso cref="MaxEvaluations"/>
+ /// <seealso cref="MinBreakWordLength"/>
+ /// <seealso cref="MinSuggestionFrequency"/>
public WordBreakSpellChecker()
{
}
/// <summary>
- /// <para>
/// Determines the order to list word break suggestions
- /// </para>
/// </summary>
public enum BreakSuggestionSortMethod
{
@@ -75,19 +73,16 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// <para>
/// Generate suggestions by breaking the passed-in term into multiple words.
/// The scores returned are equal to the number of word breaks needed so a
/// lower score is generally preferred over a higher score.
- /// </para>
/// </summary>
/// <param name="suggestMode">
- /// - default = <seealso cref="SuggestMode#SUGGEST_WHEN_NOT_IN_INDEX"/> </param>
+ /// - default = <see cref="SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX"/> </param>
/// <param name="sortMethod">
- /// - default =
- /// <seealso cref="BreakSuggestionSortMethod#NUM_CHANGES_THEN_MAX_FREQUENCY"/> </param>
+ /// - default = <see cref="BreakSuggestionSortMethod.NUM_CHANGES_THEN_MAX_FREQUENCY"/> </param>
/// <returns> one or more arrays of words formed by breaking up the original term </returns>
- /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+ /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
public virtual SuggestWord[][] SuggestWordBreaks(Term term, int maxSuggestions, IndexReader ir, SuggestMode suggestMode, BreakSuggestionSortMethod sortMethod)
{
if (maxSuggestions < 1)
@@ -135,30 +130,30 @@ namespace Lucene.Net.Search.Spell
/// <summary>
/// <para>
/// Generate suggestions by combining one or more of the passed-in terms into
- /// single words. The returned <seealso cref="CombineSuggestion"/> contains both a
- /// <seealso cref="SuggestWord"/> and also an array detailing which passed-in terms were
+ /// single words. The returned <see cref="CombineSuggestion"/> contains both a
+ /// <see cref="SuggestWord"/> and also an array detailing which passed-in terms were
/// involved in creating this combination. The scores returned are equal to the
/// number of word combinations needed, also one less than the length of the
- /// array <seealso cref="CombineSuggestion#originalTermIndexes"/>. Generally, a
+ /// array <see cref="CombineSuggestion.OriginalTermIndexes"/>. Generally, a
/// suggestion with a lower score is preferred over a higher score.
/// </para>
/// <para>
/// To prevent two adjacent terms from being combined (for instance, if one is
/// mandatory and the other is prohibited), separate the two terms with
- /// <seealso cref="WordBreakSpellChecker#SEPARATOR_TERM"/>
+ /// <see cref="WordBreakSpellChecker.SEPARATOR_TERM"/>
/// </para>
/// <para>
- /// When suggestMode equals <seealso cref="SuggestMode#SUGGEST_WHEN_NOT_IN_INDEX"/>, each
+ /// When suggestMode equals <see cref="SuggestMode.SUGGEST_WHEN_NOT_IN_INDEX"/>, each
/// suggestion will include at least one term not in the index.
/// </para>
/// <para>
- /// When suggestMode equals <seealso cref="SuggestMode#SUGGEST_MORE_POPULAR"/>, each
+ /// When suggestMode equals <see cref="SuggestMode.SUGGEST_MORE_POPULAR"/>, each
/// suggestion will have the same, or better frequency than the most-popular
/// included term.
/// </para>
/// </summary>
/// <returns> an array of words generated by combining original terms </returns>
- /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
+ /// <exception cref="System.IO.IOException"> If there is a low-level I/O error. </exception>
public virtual CombineSuggestion[] SuggestWordCombinations(Term[] terms, int maxSuggestions, IndexReader ir, SuggestMode suggestMode)
{
if (maxSuggestions < 1)
@@ -363,9 +358,10 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Returns the minimum frequency a term must have
- /// to be part of a suggestion. </summary>
- /// <seealso cref= #setMinSuggestionFrequency(int) </seealso>
+ /// Gets or sets the minimum frequency a term must have to be
+ /// included as part of a suggestion. Default=1 Not applicable when used with
+ /// <see cref="SuggestMode.SUGGEST_MORE_POPULAR"/>
+ /// </summary>
public virtual int MinSuggestionFrequency
{
get
@@ -379,8 +375,9 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Returns the maximum length of a combined suggestion </summary>
- /// <seealso cref= #setMaxCombineWordLength(int) </seealso>
+ /// Gets or sets the maximum length of a suggestion made
+ /// by combining 1 or more original terms. Default=20.
+ /// </summary>
public virtual int MaxCombineWordLength
{
get
@@ -394,8 +391,8 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Returns the minimum size of a broken word </summary>
- /// <seealso cref= #setMinBreakWordLength(int) </seealso>
+ /// Gets or sets the minimum length to break words down to. Default=1.
+ /// </summary>
public virtual int MinBreakWordLength
{
get
@@ -409,8 +406,9 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Returns the maximum number of changes to perform on the input </summary>
- /// <seealso cref= #setMaxChanges(int) </seealso>
+ /// Gets or sets the maximum numbers of changes (word breaks or combinations) to make
+ /// on the original term(s). Default=1.
+ /// </summary>
public virtual int MaxChanges
{
get
@@ -424,8 +422,9 @@ namespace Lucene.Net.Search.Spell
}
/// <summary>
- /// Returns the maximum number of word combinations to evaluate. </summary>
- /// <seealso cref= #setMaxEvaluations(int) </seealso>
+ /// Gets or sets the maximum number of word combinations to evaluate. Default=1000. A higher
+ /// value might improve result quality. A lower value might improve performance.
+ /// </summary>
public virtual int MaxEvaluations
{
get
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
index 23a38eb..4ce7e27 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
@@ -70,13 +70,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Field name used for the indexed text, as a
- /// StringField, for exact lookup.
+ /// <see cref="StringField"/>, for exact lookup.
/// </summary>
protected internal const string EXACT_TEXT_FIELD_NAME = "exacttext";
/// <summary>
/// Field name used for the indexed context, as a
- /// StringField and a SortedSetDVField, for filtering.
+ /// <see cref="StringField"/> and a <see cref="SortedSetDocValuesField"/>, for filtering.
/// </summary>
protected internal const string CONTEXTS_FIELD_NAME = "contexts";
@@ -95,7 +95,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
private IndexWriter writer;
/// <summary>
- /// <seealso cref="IndexSearcher"/> used for lookups. </summary>
+ /// <see cref="IndexSearcher"/> used for lookups. </summary>
protected internal SearcherManager searcherMgr;
/// <summary>
@@ -110,10 +110,11 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Create a new instance, loading from a previously built
- /// AnalyzingInfixSuggester directory, if it exists. This directory must be
- /// private to the infix suggester (i.e., not an external
- /// Lucene index). Note that <seealso cref="#close"/>
- /// will also close the provided directory.
+ /// <see cref="AnalyzingInfixSuggester"/> directory, if it exists.
+ /// This directory must be
+ /// private to the infix suggester (i.e., not an external
+ /// Lucene index). Note that <see cref="Dispose()"/>
+ /// will also dispose the provided directory.
/// </summary>
public AnalyzingInfixSuggester(LuceneVersion matchVersion, Directory dir, Analyzer analyzer)
: this(matchVersion, dir, analyzer, analyzer, DEFAULT_MIN_PREFIX_CHARS)
@@ -122,13 +123,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Create a new instance, loading from a previously built
- /// AnalyzingInfixSuggester directory, if it exists. This directory must be
- /// private to the infix suggester (i.e., not an external
- /// Lucene index). Note that <seealso cref="#close"/>
- /// will also close the provided directory.
+ /// <see cref="AnalyzingInfixSuggester"/> directory, if it exists. This directory must be
+ /// private to the infix suggester (i.e., not an external
+ /// Lucene index). Note that <see cref="Dispose()"/>
+ /// will also dispose the provided directory.
/// </summary>
/// <param name="minPrefixChars"> Minimum number of leading characters
- /// before PrefixQuery is used (default 4).
+ /// before <see cref="PrefixQuery"/> is used (default 4).
/// Prefixes shorter than this are indexed as character
/// ngrams (increasing index size but making lookups
/// faster). </param>
@@ -156,7 +157,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Override this to customize index settings, e.g. which
- /// codec to use.
+ /// codec to use.
/// </summary>
protected internal virtual IndexWriterConfig GetIndexWriterConfig(LuceneVersion matchVersion, Analyzer indexAnalyzer, IndexWriterConfig.OpenMode_e openMode)
{
@@ -173,8 +174,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
}
/// <summary>
- /// Subclass can override to choose a specific {@link
- /// Directory} implementation.
+ /// Subclass can override to choose a specific
+ /// <see cref="Directory"/> implementation.
/// </summary>
protected internal virtual Directory GetDirectory(DirectoryInfo path)
{
@@ -283,11 +284,11 @@ namespace Lucene.Net.Search.Suggest.Analyzing
}
/// <summary>
- /// Adds a new suggestion. Be sure to use <seealso cref="#update"/>
- /// instead if you want to replace a previous suggestion.
- /// After adding or updating a batch of new suggestions,
- /// you must call <seealso cref="#refresh"/> in the end in order to
- /// see the suggestions in <seealso cref="#lookup"/>
+ /// Adds a new suggestion. Be sure to use <see cref="Update"/>
+ /// instead if you want to replace a previous suggestion.
+ /// After adding or updating a batch of new suggestions,
+ /// you must call <see cref="Refresh()"/> in the end in order to
+ /// see the suggestions in <see cref="DoLookup"/>
/// </summary>
public virtual void Add(BytesRef text, IEnumerable<BytesRef> contexts, long weight, BytesRef payload)
{
@@ -296,12 +297,12 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Updates a previous suggestion, matching the exact same
- /// text as before. Use this to change the weight or
- /// payload of an already added suggstion. If you know
- /// this text is not already present you can use {@link
- /// #add} instead. After adding or updating a batch of
- /// new suggestions, you must call <seealso cref="#refresh"/> in the
- /// end in order to see the suggestions in <seealso cref="#lookup"/>
+ /// text as before. Use this to change the weight or
+ /// payload of an already added suggstion. If you know
+ /// this text is not already present you can use <see cref="Add"/>
+ /// instead. After adding or updating a batch of
+ /// new suggestions, you must call <see cref="Refresh()"/> in the
+ /// end in order to see the suggestions in <see cref="DoLookup"/>
/// </summary>
public virtual void Update(BytesRef text, IEnumerable<BytesRef> contexts, long weight, BytesRef payload)
{
@@ -339,8 +340,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Reopens the underlying searcher; it's best to "batch
- /// up" many additions/updates, and then call refresh
- /// once in the end.
+ /// up" many additions/updates, and then call refresh
+ /// once in the end.
/// </summary>
public virtual void Refresh()
{
@@ -378,8 +379,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// This is called if the last token isn't ended
- /// (e.g. user did not type a space after it). Return an
- /// appropriate Query clause to add to the BooleanQuery.
+ /// (e.g. user did not type a space after it). Return an
+ /// appropriate <see cref="Query"/> clause to add to the <see cref="BooleanQuery"/>.
/// </summary>
protected internal virtual Query GetLastTokenQuery(string token)
{
@@ -394,8 +395,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Retrieve suggestions, specifying whether all terms
- /// must match ({@code allTermsRequired}) and whether the hits
- /// should be highlighted ({@code doHighlight}).
+ /// must match (<paramref name="allTermsRequired"/>) and whether the hits
+ /// should be highlighted (<paramref name="doHighlight"/>).
/// </summary>
public virtual IList<LookupResult> DoLookup(string key, IEnumerable<BytesRef> contexts, int num, bool allTermsRequired, bool doHighlight)
{
@@ -541,7 +542,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Create the results based on the search hits.
/// Can be overridden by subclass to add particular behavior (e.g. weight transformation) </summary>
- /// <exception cref="IOException"> If there are problems reading fields from the underlying Lucene index. </exception>
+ /// <exception cref="System.IO.IOException"> If there are problems reading fields from the underlying Lucene index. </exception>
protected internal virtual IList<LookupResult> CreateResults(IndexSearcher searcher, TopFieldDocs hits, int num, string charSequence, bool doHighlight, IEnumerable<string> matchedTokens, string prefixToken)
{
@@ -612,7 +613,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Subclass can override this to tweak the Query before
- /// searching.
+ /// searching.
/// </summary>
protected internal virtual Query FinishQuery(BooleanQuery bq, bool allTermsRequired)
{
@@ -621,9 +622,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Override this method to customize the Object
- /// representing a single highlighted suggestions; the
- /// result is set on each {@link
- /// LookupResult#highlightKey} member.
+ /// representing a single highlighted suggestions; the
+ /// result is set on each <see cref="Lookup.LookupResult.highlightKey"/>
+ /// member.
/// </summary>
protected internal virtual object Highlight(string text, IEnumerable<string> matchedTokens, string prefixToken)
{
@@ -678,10 +679,10 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Called while highlighting a single result, to append a
- /// non-matching chunk of text from the suggestion to the
- /// provided fragments list. </summary>
- /// <param name="sb"> The {@code StringBuilder} to append to </param>
- /// <param name="text"> The text chunk to add </param>
+ /// non-matching chunk of text from the suggestion to the
+ /// provided fragments list. </summary>
+ /// <param name="sb"> The <see cref="StringBuilder"/> to append to </param>
+ /// <param name="text"> The text chunk to add </param>
protected internal virtual void AddNonMatch(StringBuilder sb, string text)
{
sb.Append(text);
@@ -689,10 +690,10 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Called while highlighting a single result, to append
- /// the whole matched token to the provided fragments list. </summary>
- /// <param name="sb"> The {@code StringBuilder} to append to </param>
- /// <param name="surface"> The surface form (original) text </param>
- /// <param name="analyzed"> The analyzed token corresponding to the surface form text </param>
+ /// the whole matched token to the provided fragments list. </summary>
+ /// <param name="sb"> The <see cref="StringBuilder"/> to append to </param>
+ /// <param name="surface"> The surface form (original) text </param>
+ /// <param name="analyzed"> The analyzed token corresponding to the surface form text </param>
protected internal virtual void AddWholeMatch(StringBuilder sb, string surface, string analyzed)
{
sb.Append("<b>");
@@ -702,13 +703,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Called while highlighting a single result, to append a
- /// matched prefix token, to the provided fragments list. </summary>
- /// <param name="sb"> The {@code StringBuilder} to append to </param>
- /// <param name="surface"> The fragment of the surface form
- /// (indexed during <seealso cref="#build"/>, corresponding to
+ /// matched prefix token, to the provided fragments list. </summary>
+ /// <param name="sb"> The <see cref="StringBuilder"/> to append to </param>
+ /// <param name="surface"> The fragment of the surface form
+ /// (indexed during <see cref="Build(IInputIterator)"/>, corresponding to
/// this match </param>
- /// <param name="analyzed"> The analyzed token that matched </param>
- /// <param name="prefixToken"> The prefix of the token that matched </param>
+ /// <param name="analyzed"> The analyzed token that matched </param>
+ /// <param name="prefixToken"> The prefix of the token that matched </param>
protected internal virtual void AddPrefixMatch(StringBuilder sb, string surface, string analyzed, string prefixToken)
{
// TODO: apps can try to invert their analysis logic
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
index d0f4a0d..95d4ff6 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
@@ -43,7 +43,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// suggestion "The Ghost of Christmas Past". Note that
/// position increments MUST NOT be preserved for this example
/// to work, so you should call the constructor with
- /// <code>preservePositionIncrements</code> parameter set to
+ /// <paramref name="preservePositionIncrements"/> parameter set to
/// false
///
/// </para>
@@ -63,24 +63,24 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// </para>
/// <para>
/// There are some limitations:
- /// <ul>
+ /// <list type="number">
///
- /// <li> A lookup from a query like "net" in English won't
+ /// <item> A lookup from a query like "net" in English won't
/// be any different than "net " (ie, user added a
/// trailing space) because analyzers don't reflect
/// when they've seen a token separator and when they
- /// haven't.
+ /// haven't.</item>
///
- /// <li> If you're using {@code StopFilter}, and the user will
+ /// <item> If you're using <see cref="Analysis.Core.StopFilter"/>, and the user will
/// type "fast apple", but so far all they've typed is
/// "fast a", again because the analyzer doesn't convey whether
/// it's seen a token separator after the "a",
- /// {@code StopFilter} will remove that "a" causing
- /// far more matches than you'd expect.
+ /// <see cref="Analysis.Core.StopFilter"/> will remove that "a" causing
+ /// far more matches than you'd expect.</item>
///
- /// <li> Lookups with the empty string return no results
- /// instead of all results.
- /// </ul>
+ /// <item> Lookups with the empty string return no results
+ /// instead of all results.</item>
+ /// </list>
///
/// @lucene.experimental
/// </para>
@@ -89,10 +89,10 @@ namespace Lucene.Net.Search.Suggest.Analyzing
{
/// <summary>
- /// FST<Weight,Surface>:
- /// input is the analyzed form, with a null byte between terms
- /// weights are encoded as costs: (Integer.MAX_VALUE-weight)
- /// surface is the original, unanalyzed form.
+ /// FST(Weight,Surface):
+ /// input is the analyzed form, with a null byte between terms
+ /// weights are encoded as costs: (<see cref="int.MaxValue"/> - weight)
+ /// surface is the original, unanalyzed form.
/// </summary>
private FST<PairOutputs<long?, BytesRef>.Pair> fst = null;
@@ -119,18 +119,18 @@ namespace Lucene.Net.Search.Suggest.Analyzing
private readonly bool preserveSep;
/// <summary>
- /// Include this flag in the options parameter to {@link
- /// #AnalyzingSuggester(Analyzer,Analyzer,int,int,int,boolean)} to always
- /// return the exact match first, regardless of score. This
- /// has no performance impact but could result in
- /// low-quality suggestions.
+ /// Include this flag in the options parameter to
+ /// <see cref="AnalyzingSuggester(Analyzer,Analyzer,int,int,int,bool)"/> to always
+ /// return the exact match first, regardless of score. This
+ /// has no performance impact but could result in
+ /// low-quality suggestions.
/// </summary>
public const int EXACT_FIRST = 1;
/// <summary>
- /// Include this flag in the options parameter to {@link
- /// #AnalyzingSuggester(Analyzer,Analyzer,int,int,int,boolean)} to preserve
- /// token separators when matching.
+ /// Include this flag in the options parameter to
+ /// <see cref="AnalyzingSuggester(Analyzer,Analyzer,int,int,int,bool)"/> to preserve
+ /// token separators when matching.
/// </summary>
public const int PRESERVE_SEP = 2;
@@ -180,9 +180,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
private long count = 0;
/// <summary>
- /// Calls {@link #AnalyzingSuggester(Analyzer,Analyzer,int,int,int,boolean)
- /// AnalyzingSuggester(analyzer, analyzer, EXACT_FIRST |
- /// PRESERVE_SEP, 256, -1, true)}
+ /// Calls <see cref="AnalyzingSuggester(Analyzer,Analyzer,int,int,int,bool)">
+ /// AnalyzingSuggester(analyzer, analyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true)
+ /// </see>
/// </summary>
public AnalyzingSuggester(Analyzer analyzer)
: this(analyzer, analyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true)
@@ -190,9 +190,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
}
/// <summary>
- /// Calls {@link #AnalyzingSuggester(Analyzer,Analyzer,int,int,int,boolean)
- /// AnalyzingSuggester(indexAnalyzer, queryAnalyzer, EXACT_FIRST |
- /// PRESERVE_SEP, 256, -1, true)}
+ /// Calls <see cref="AnalyzingSuggester(Analyzer,Analyzer,int,int,int,bool)">
+ /// AnalyzingSuggester(indexAnalyzer, queryAnalyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true)
+ /// </see>
/// </summary>
public AnalyzingSuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer)
: this(indexAnalyzer, queryAnalyzer, EXACT_FIRST | PRESERVE_SEP, 256, -1, true)
@@ -206,7 +206,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// analyzing suggestions while building the index. </param>
/// <param name="queryAnalyzer"> Analyzer that will be used for
/// analyzing query text during lookup </param>
- /// <param name="options"> see <seealso cref="#EXACT_FIRST"/>, <seealso cref="#PRESERVE_SEP"/> </param>
+ /// <param name="options"> see <see cref="EXACT_FIRST"/>, <see cref="PRESERVE_SEP"/> </param>
/// <param name="maxSurfaceFormsPerAnalyzedForm"> Maximum number of
/// surface forms to keep for a single analyzed form.
/// When there are too many surface forms we discard the
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
index 7c82ef1..fb3ba65 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
@@ -31,7 +31,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
// - allow to use the search score
/// <summary>
- /// Extension of the AnalyzingInfixSuggester which transforms the weight
+ /// Extension of the <see cref="AnalyzingInfixSuggester"/> which transforms the weight
/// after search to take into account the position of the searched term into
/// the indexed text.
/// Please note that it increases the number of elements searched and applies the
@@ -68,20 +68,26 @@ namespace Lucene.Net.Search.Suggest.Analyzing
public enum BlenderType
{
/// <summary>
- /// Application dependent; override {@link
- /// #calculateCoefficient} to compute it.
+ /// Application dependent; override <see cref="CalculateCoefficient(int)"/>
+ /// to compute it.
/// </summary>
CUSTOM,
/// <summary>
- /// weight*(1 - 0.10*position) </summary>
+ /// weight*(1 - 0.10*position)
+ /// </summary>
POSITION_LINEAR,
/// <summary>
- /// weight/(1+position) </summary>
+ /// weight/(1+position)
+ /// </summary>
POSITION_RECIPROCAL,
// TODO:
//SCORE
}
+ /// <summary>
+ /// LUCENENET specific to ensure our Queue is only altered by a single
+ /// thread at a time.
+ /// </summary>
private static readonly object syncLock = new object();
/// <summary>
@@ -101,7 +107,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// </summary>
/// <param name="blenderType"> Type of blending strategy, see BlenderType for more precisions </param>
/// <param name="numFactor"> Factor to multiply the number of searched elements before ponderate </param>
- /// <exception cref="IOException"> If there are problems opening the underlying Lucene index. </exception>
+ /// <exception cref="System.IO.IOException"> If there are problems opening the underlying Lucene index. </exception>
public BlendedInfixSuggester(LuceneVersion matchVersion, Directory dir, Analyzer indexAnalyzer, Analyzer queryAnalyzer, int minPrefixChars, BlenderType blenderType, int numFactor)
: base(matchVersion, dir, indexAnalyzer, queryAnalyzer, minPrefixChars)
{
@@ -247,7 +253,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <param name="matchedTokens"> tokens found in the query </param>
/// <param name="prefixToken"> unfinished token in the query </param>
/// <returns> the coefficient </returns>
- /// <exception cref="IOException"> If there are problems reading term vectors from the underlying Lucene index. </exception>
+ /// <exception cref="System.IO.IOException"> If there are problems reading term vectors from the underlying Lucene index. </exception>
private double CreateCoefficient(IndexSearcher searcher, int doc, IEnumerable<string> matchedTokens, string prefixToken)
{
Terms tv = searcher.IndexReader.GetTermVector(doc, TEXT_FIELD_NAME);
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
index 3255a36..3aed4d4 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Exposes a utility method to enumerate all paths
- /// intersecting an <seealso cref="Automaton"/> with an <seealso cref="FST"/>.
+ /// intersecting an <see cref="Automaton"/> with an <see cref="FST"/>.
/// </summary>
public class FSTUtil
{
@@ -45,7 +45,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
public readonly State state;
/// <summary>
- /// Node in the FST where path ends: </summary>
+ /// Node in the <see cref="FST"/> where path ends: </summary>
public readonly FST.Arc<T> fstNode;
/// <summary>
@@ -68,8 +68,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
}
/// <summary>
- /// Enumerates all minimal prefix paths in the automaton that also intersect the FST,
- /// accumulating the FST end node and output for each path.
+ /// Enumerates all minimal prefix paths in the automaton that also intersect the <see cref="FST"/>,
+ /// accumulating the <see cref="FST"/> end node and output for each path.
/// </summary>
public static IList<Path<T>> IntersectPrefixPaths<T>(Automaton a, FST<T> fst)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9a6f9734/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
index 0a52947..3bd5f4d 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
@@ -39,9 +39,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
// - add pruning of low-freq ngrams?
/// <summary>
- /// Builds an ngram model from the text sent to {@link
- /// #build} and predicts based on the last grams-1 tokens in
- /// the request sent to <seealso cref="#lookup"/>. This tries to
+ /// Builds an ngram model from the text sent to <see cref="Build"/>
+ /// and predicts based on the last grams-1 tokens in
+ /// the request sent to <see cref="DoLookup"/>. This tries to
/// handle the "long tail" of suggestions for when the
/// incoming query is a never before seen query string.
///
@@ -56,18 +56,17 @@ namespace Lucene.Net.Search.Suggest.Analyzing
///
/// </para>
/// <para>This uses the stupid backoff language model to smooth
- /// scores across ngram models; see
- /// "Large language models in machine translation",
- /// http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.76.1126
- /// for details.
+ /// scores across ngram models; see
+ /// <a href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.76.1126">
+ /// "Large language models in machine translation"</a> for details.
///
/// </para>
- /// <para> From <seealso cref="#lookup"/>, the key of each result is the
- /// ngram token; the value is Long.MAX_VALUE * score (fixed
- /// point, cast to long). Divide by Long.MAX_VALUE to get
+ /// <para> From <see cref="DoLookup"/>, the key of each result is the
+ /// ngram token; the value is <see cref="long.MaxValue"/> * score (fixed
+ /// point, cast to long). Divide by <see cref="long.MaxValue"/> to get
/// the score back, which ranges from 0.0 to 1.0.
///
- /// onlyMorePopular is unused.
+ /// <paramref name="onlyMorePopular"/> is unused.
///
/// @lucene.experimental
/// </para>
@@ -131,14 +130,14 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// The default character used to join multiple tokens
- /// into a single ngram token. The input tokens produced
- /// by the analyzer must not contain this character.
+ /// into a single ngram token. The input tokens produced
+ /// by the analyzer must not contain this character.
/// </summary>
public const byte DEFAULT_SEPARATOR = 0x1e;
/// <summary>
/// Instantiate, using the provided analyzer for both
- /// indexing and lookup, using bigram model by default.
+ /// indexing and lookup, using bigram model by default.
/// </summary>
public FreeTextSuggester(Analyzer analyzer)
: this(analyzer, analyzer, DEFAULT_GRAMS)
@@ -147,7 +146,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Instantiate, using the provided indexing and lookup
- /// analyzers, using bigram model by default.
+ /// analyzers, using bigram model by default.
/// </summary>
public FreeTextSuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer)
: this(indexAnalyzer, queryAnalyzer, DEFAULT_GRAMS)
@@ -156,8 +155,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Instantiate, using the provided indexing and lookup
- /// analyzers, with the specified model (2
- /// = bigram, 3 = trigram, etc.).
+ /// analyzers, with the specified model (2
+ /// = bigram, 3 = trigram, etc.).
/// </summary>
public FreeTextSuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer, int grams)
: this(indexAnalyzer, queryAnalyzer, grams, DEFAULT_SEPARATOR)
@@ -166,13 +165,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
/// <summary>
/// Instantiate, using the provided indexing and lookup
- /// analyzers, and specified model (2 = bigram, 3 =
- /// trigram ,etc.). The separator is passed to {@link
- /// ShingleFilter#setTokenSeparator} to join multiple
- /// tokens into a single ngram token; it must be an ascii
- /// (7-bit-clean) byte. No input tokens should have this
- /// byte, otherwise {@code IllegalArgumentException} is
- /// thrown.
+ /// analyzers, and specified model (2 = bigram, 3 =
+ /// trigram ,etc.). The separator is passed to <see cref="ShingleFilter.TokenSeparator"/>
+ /// to join multiple
+ /// tokens into a single ngram token; it must be an ascii
+ /// (7-bit-clean) byte. No input tokens should have this
+ /// byte, otherwise <see cref="ArgumentException"/> is
+ /// thrown.
/// </summary>
public FreeTextSuggester(Analyzer indexAnalyzer, Analyzer queryAnalyzer, int grams, byte separator)
{
@@ -886,7 +885,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
}
// NOTE: copied from WFSTCompletionLookup & tweaked
- private long? LookupPrefix(FST<long?> fst, FST.BytesReader bytesReader, BytesRef scratch, FST.Arc<long?> arc) //Bogus
+ private long? LookupPrefix(FST<long?> fst, FST.BytesReader bytesReader, BytesRef scratch, FST.Arc<long?> arc)
{
long? output = fst.Outputs.NoOutput;