+ ///
/// Examples of appropriately formatted queries can be found in the query syntax /// documentation. /// /// - ///+ ///
/// In {@link TermRangeQuery}s, QueryParser tries to detect date values, e.g. /// date:[6/1/2005 TO 6/4/2005] produces a range query that searches /// for "date" fields between 2005-06-01 and 2005-06-04. Note that the format @@ -88,7 +88,7 @@ /// To use the new {@link DateTools} to convert dates, a /// {@link Lucene.Net.Documents.DateTools.Resolution} has to be set. /// - ///+ ///
/// The date resolution that shall be used for RangeQueries can be set /// using {@link #SetDateResolution(DateTools.Resolution)} /// or {@link #SetDateResolution(String, DateTools.Resolution)}. The former @@ -96,7 +96,7 @@ /// be used to set field specific date resolutions. Field specific date /// resolutions take, if set, precedence over the default date resolution. /// - ///+ ///
/// If you use neither {@link DateField} nor {@link DateTools} in your /// index, you can create your own /// query parser that inherits QueryParser and overwrites @@ -104,14 +104,14 @@ /// use a different method for date conversion. /// /// - ///Note that QueryParser is not thread-safe.
+ /// Note that QueryParser is not thread-safe. /// - ///NOTE: there is a new QueryParser in contrib, which matches + ///
NOTE: there is a new QueryParser in contrib, which matches /// the same syntax as this class, but is more modular, /// enabling substantial customization to how a query is created. /// /// - ///NOTE: there is a new QueryParser in contrib, which matches + ///
NOTE: there is a new QueryParser in contrib, which matches /// the same syntax as this class, but is more modular, /// enabling substantial customization to how a query is created. /// @@ -311,12 +311,12 @@ ///true to allow leading wildcard characters.
- /// + ///
/// When set,* or ? are allowed as
/// the first character of a PrefixQuery and WildcardQuery.
/// Note that this can produce very slow
/// queries on big indexes.
- /// + ///
/// Default: false. ///true to enable position increments in result query.
- /// + ///
/// When set, result phrase and multi-phrase queries will /// be aware of position increments. /// Useful when e.g. a StopFilter increases the position increment of /// the token that follows an omitted token. - ///+ ///
/// Default: false. ///+ ///
/// Depending on settings, prefix term may be lower-cased /// automatically. It will not go through the default Analyzer, /// however, since normal Analyzers are unlikely to work properly /// with wildcard templates. - ///+ ///
/// Can be overridden by extending classes, to provide custom handling for /// wildcard queries, which may be necessary due to missing analyzer calls. /// @@ -1183,12 +1183,12 @@ /// character as its last character. Since this is a special case /// of generic wildcard term, and such a query can be optimized easily, /// this usually results in a different query object. - ///+ ///
/// Depending on settings, a prefix term may be lower-cased /// automatically. It will not go through the default Analyzer, /// however, since normal Analyzers are unlikely to work properly /// with wildcard templates. - ///+ ///
/// Can be overridden by extending classes, to provide custom handling for /// wild card queries, which may be necessary due to missing analyzer calls. /// Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/BooleanQuery.cs?rev=890338&r1=890337&r2=890338&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs Mon Dec 14 14:13:03 2009 @@ -150,17 +150,17 @@ ///+ ///
/// By default no optional clauses are necessary for a match /// (unless there are no required clauses). If this method is used, /// then the specified number of clauses is required. /// - ///+ ///
/// Use of this method is totally independent of specifying that /// any specific clauses are required (or prohibited). This number will /// only be compared against the number of matching optional clauses. /// - ///+ ///
/// EXPERT NOTE: Using this method may force collecting docs in order, /// regardless of whether setAllowDocsOutOfOrder(true) has been called. /// @@ -222,7 +222,7 @@ ///NOTE: this API and implementation is subject to + ///
NOTE: this API and implementation is subject to /// change suddenly in the next release. ///+ ///
/// Background: although the contract of the Scorer class requires that /// documents be iterated in order of doc id, this was not true in early /// versions of Lucene. Many pieces of functionality in the current Lucene code @@ -485,7 +485,7 @@ /// queries.) /// /// - ///+ ///
/// Specifics: By setting this option to true, docid N might be scored for a /// single segment before docid N-1. Across multiple segments, docs may be /// scored out of order regardless of this setting - it only applies to scoring Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Collector.cs?rev=890338&r1=890337&r2=890338&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs Mon Dec 14 14:13:03 2009 @@ -22,18 +22,18 @@ namespace Lucene.Net.Search { - ///Expert: Collectors are primarily meant to be used to
+ ///
As of 2.9, this class replaces the deprecated + ///
As of 2.9, this class replaces the deprecated /// HitCollector, and offers an API for efficient collection /// of hits across sequential {@link IndexReader}s. {@link /// IndexSearcher} advances the collector through each of the /// sub readers, in an arbitrary order. This results in a /// higher performance means of collection. /// - ///Lucene's core collectors are derived from Collector. + ///
Lucene's core collectors are derived from Collector. /// Likely your application can use one of these classes, or /// subclass {@link TopDocsCollector}, instead of /// implementing Collector directly: @@ -69,7 +69,7 @@ /// /// /// - ///Collector decouples the score from the collected doc: + ///
Collector decouples the score from the collected doc: /// the score computation is skipped entirely if it's not /// needed. Collectors that do need the score should /// implement the {@link #setScorer} method, to hold onto the @@ -79,7 +79,7 @@ /// score for a single hit multiple times, you should use /// {@link ScoreCachingWrappingScorer}. /// - ///NOTE: The doc that is passed to the collect + ///
NOTE: The doc that is passed to the collect /// method is relative to the current reader. If your /// collector needs to resolve this to the docID space of the /// Multi*Reader, you must re-base it by recording the @@ -112,11 +112,11 @@ /// }); /// /// - ///Not all collectors will need to rebase the docID. For + ///
Not all collectors will need to rebase the docID. For /// example, a collector that simply counts the total number /// of hits would skip it. /// - ///NOTE: Prior to 2.9, Lucene silently filtered + ///
NOTE: Prior to 2.9, Lucene silently filtered /// out hits with score <= 0. As of 2.9, the core Collectors /// no longer do that. It's very unusual to have such hits /// (a negative query boost, or function query returning @@ -124,7 +124,7 @@ /// you need that behavior, use {@link /// PositiveScoresOnlyCollector}. /// - ///NOTE: This API is experimental and might change + ///
NOTE: This API is experimental and might change /// in incompatible ways in the next release. /// ///+ ///
/// Note: This is called in an inner search loop. For good search performance, /// implementations of this method should not call {@link Searcher#Doc(int)} or /// {@link Lucene.Net.Index.IndexReader#Document(int)} on every hit. @@ -166,7 +166,7 @@ ///+ ///
/// NOTE: some collectors can work in either mode, with a more efficient /// implementation for in-order docs collection. If your collector can work in /// either mode, it is recommended that you create two variants of it, since Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ComplexExplanation.cs?rev=890338&r1=890337&r2=890338&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs Mon Dec 14 14:13:03 2009 @@ -56,7 +56,7 @@ } ///+ ///
/// If the match status is explicitly set (i.e.: not null) this method /// uses it; otherwise it defers to the superclass. /// Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs?rev=890338&r1=890337&r2=890338&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ConstantScoreRangeQuery.cs Mon Dec 14 14:13:03 2009 @@ -23,13 +23,13 @@ ///It does not have an upper bound on the number of clauses covered in the range. + ///
It does not have an upper bound on the number of clauses covered in the range. /// - ///This query matches the documents looking for terms that fall into the + ///
This query matches the documents looking for terms that fall into the /// supplied range according to {@link String#compareTo(String)}. It is not intended /// for numerical ranges, use {@link NumericRangeQuery} instead. /// - ///This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}. + ///
This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}. /// If you want to change this, use {@link TermRangeQuery} instead. /// ///WARNING: This API is new and experimental, and may suddenly + ///
WARNING: This API is new and experimental, and may suddenly /// change. ///WARNING: This API is new and experimental, and may suddenly + ///
WARNING: This API is new and experimental, and may suddenly /// change. /// ///NOTE: this API and implementation is subject to + ///
NOTE: this API and implementation is subject to /// change suddenly in the next release. ///+ ///
/// After each to call to next() or skipTo() ///currentSumScore is the total score of the current matching doc,
/// nrMatchers is the number of matching scorers,
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DocIdSetIterator.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs Mon Dec 14 14:13:03 2009
@@ -56,7 +56,7 @@
/// + ///
/// NOTE: in 3.0, this method will become abstract. /// ///+ ///
/// Behaves as if written: /// ///@@ -131,18 +131,18 @@ ////// /// Some implementations are considerably more efficient than that. - ///
+ ///
/// NOTE: certain implemenations may return a different value (each /// time) if called several times in a row with the same target. - ///+ ///
/// NOTE: this method may be called with {@value #NO_MORE_DOCS} for /// efficiency by some Scorers. If your implementation cannot efficiently /// determine that it should exhaust, it is recommended that you check for that /// value in each call to this method. - ///+ ///
/// NOTE: after the iterator has exhausted you should not call this /// method, as it may result in unpredicted behavior. - ///+ ///
/// NOTE: in 3.0 this method will become abstract, following the removal /// of {@link #SkipTo(int)}. /// Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Explanation.cs?rev=890338&r1=890337&r2=890338&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs Mon Dec 14 14:13:03 2009 @@ -40,7 +40,7 @@ ///+ ///
/// By default, an Explanation represents a "match" if the value is positive. /// ///Created: May 19, 2004 11:13:14 AM + ///
Created: May 19, 2004 11:13:14 AM /// ///+ ///
/// EXPERIMENTAL API: This API is considered extremely advanced /// and experimental. It may be removed or altered w/o warning in future /// releases @@ -633,13 +633,13 @@ ///+ ///
/// NOTE: These CacheEntry objects maintain a strong refrence to the /// Cached Values. Maintaining refrences to a CacheEntry the IndexReader /// associated with it has garbage collected will prevent the Value itself /// from being garbage collected when the Cache drops the WeakRefrence. /// - ///+ ///
/// EXPERIMENTAL API: This API is considered extremely advanced /// and experimental. It may be removed or altered w/o warning in future /// releases @@ -648,7 +648,7 @@ ///
+ ///
+ ///
/// EXPERIMENTAL API: This API is considered extremely advanced /// and experimental. It may be removed or altered w/o warning in future /// releases Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheImpl.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldCacheImpl.cs?rev=890338&r1=890337&r2=890338&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheImpl.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCacheImpl.cs Mon Dec 14 14:13:03 2009 @@ -31,7 +31,7 @@ ///Created: May 19, 2004 4:40:36 PM + ///
Created: May 19, 2004 4:40:36 PM /// ///FieldCacheRangeFilter builds a single cache for the field the first time it is used. + ///
FieldCacheRangeFilter builds a single cache for the field the first time it is used. /// Each subsequent FieldCacheRangeFilter on the same field then reuses this cache, /// even if the range itself changes. /// - ///This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast) + ///
This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast) /// as building a {@link TermRangeFilter} (or {@link ConstantScoreRangeQuery} on a {@link TermRangeFilter}) /// for each query, if using a {@link #newStringRange}. However, if the range never changes it /// is slower (around 2x as slow) than building a CachingWrapperFilter on top of a single TermRangeFilter. @@ -40,16 +40,16 @@ /// Furthermore, it does not need the numeric values encoded by {@link NumericField}. But /// it has the problem that it only works with exact one value/document (see below). /// - ///As with all {@link FieldCache} based functionality, FieldCacheRangeFilter is only valid for + ///
As with all {@link FieldCache} based functionality, FieldCacheRangeFilter is only valid for /// fields which exact one term for each document (except for {@link #newStringRange} /// where 0 terms are also allowed). Due to a restriction of {@link FieldCache}, for numeric ranges /// all terms that do not have a numeric value, 0 is assumed. /// - ///Thus it works on dates, prices and other single value fields but will not work on + ///
Thus it works on dates, prices and other single value fields but will not work on /// regular text fields. It is preferable to use aNOT_ANALYZED field to ensure that
/// there is only a single term.
///
- /// This class does not have an constructor, use one of the static factory methods available, + ///
This class does not have an constructor, use one of the static factory methods available, /// that create a correct instance for different data types supported by {@link FieldCache}. ///This API is designed to achieve high performance + ///
This API is designed to achieve high performance /// sorting, by exposing a tight interaction with {@link /// FieldValueHitQueue} as it visits hits. Whenever a hit is /// competitive, it's enrolled into a virtual slot, which is @@ -43,7 +43,7 @@ /// during searching in case any internal state it's tracking /// needs to be recomputed during these transitions. /// - ///A comparator must define these functions:
+ /// A comparator must define these functions: /// ///For a search that hits many results, this method + ///
For a search that hits many results, this method /// will be the hotspot (invoked by far the most /// frequently). /// Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDoc.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldDoc.cs?rev=890338&r1=890337&r2=890338&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDoc.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldDoc.cs Mon Dec 14 14:13:03 2009 @@ -32,7 +32,7 @@ /// Integer, Float or String depending on the type of values /// in the terms of each field. /// - ///Created: Feb 11, 2004 1:23:38 PM + ///
Created: Feb 11, 2004 1:23:38 PM /// ///Created: Feb 11, 2004 2:04:21 PM + ///
Created: Feb 11, 2004 2:04:21 PM /// ///FieldCache.DEFAULT for maintaining internal term lookup tables.
///
- /// Created: Dec 8, 2003 12:56:03 PM + ///
Created: Dec 8, 2003 12:56:03 PM /// ///NOTE: The instances returned by this method + ///
NOTE: The instances returned by this method /// pre-allocate a full array of lengthnumHits.
///
/// + ///
/// Note: In Lucene 3.0 {@link #Bits(IndexReader)} will be removed /// and {@link #GetDocIdSet(IndexReader)} will be defined as abstract. /// All implementing classes must therefore implement {@link #GetDocIdSet(IndexReader)} Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredQuery.cs URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FilteredQuery.cs?rev=890338&r1=890337&r2=890338&view=diff ============================================================================== --- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredQuery.cs (original) +++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FilteredQuery.cs Mon Dec 14 14:13:03 2009 @@ -26,11 +26,11 @@ ///Note: the bits are retrieved from the filter each time this + ///
Note: the bits are retrieved from the filter each time this /// query is used in a search - use a CachingWrapperFilter to avoid /// regenerating the bits every time. /// - ///Created: Apr 20, 2004 8:58:29 AM + ///
Created: Apr 20, 2004 8:58:29 AM /// ///Term enumerations are always ordered by Term.compareTo(). Each term in + ///
Term enumerations are always ordered by Term.compareTo(). Each term in /// the enumeration is greater than all that precede it. ///getBytes() and makes those values
/// available as other numeric types, casting as needed.
///
- ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
@@ -37,7 +37,7 @@
/// NOTE: with the switch in 2.9 to segment-based
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
@@ -172,16 +172,16 @@
///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
@@ -46,14 +46,14 @@
*/
/// Mandatory: every DocValues implementation must implement at least this method.
+ /// Optional: DocValues implementation can (but don't have to) override this method.
+ /// Optional: DocValues implementation can (but don't have to) override this method.
+ /// Optional: DocValues implementation can (but don't have to) override this method.
+ /// Optional: DocValues implementation can (but don't have to) override this method.
+ ///
+ ///
+ ///
+ ///
+ ///
/// ModifiedScore = valSrcScore * valSrcScores[0] * valSrcScores[1] * ...
@@ -215,14 +215,14 @@
}
///
/// ModifiedScore = subQueryScore * valSrcScore
@@ -587,7 +587,7 @@
/// This may be useful when one wants full control over how scores are modified, and does
/// not care about normalizing by the ValueSource part.
/// One particular case where this is useful if for testing this query.
- ///
///
Float.NaN if this
/// DocValues instance does not contain any value.
- /// Float.NaN if this
/// DocValues instance does not contain any value.
- /// Float.NaN if this
/// DocValues instance does not contain any value. *
- ///
+ ///
/// Fields used herein nust be indexed (doesn't matter if these fields are stored or not). - ///+ ///
/// It is assumed that each such indexed field is untokenized, or at least has a single token in a document. /// For documents with multiple tokens of the same field, behavior is undefined (It is likely that current /// code would use the value of one of these tokens, but this is not guaranteed). - ///+ ///
/// Document with no tokens in this field are assigned theZero value.
///
- ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
///
- /// NOTE: with the switch in 2.9 to segment-based
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
@@ -64,7 +64,7 @@
{
///
+ ///
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
@@ -37,7 +37,7 @@
/// NOTE: with the switch in 2.9 to segment-based
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
@@ -37,7 +37,7 @@
/// NOTE: with the switch in 2.9 to segment-based
+ /// NOTE: this class adds a CPU penalty to every
+ ///
+ ///
+ ///
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
///
- /// NOTE: with the switch in 2.9 to segment-based
+ ///
+ ///
+ ///
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
///
- /// NOTE: with the switch in 2.9 to segment-based
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
@@ -37,7 +37,7 @@
/// NOTE: with the switch in 2.9 to segment-based
+ /// At its default/simplest form, values - one per doc - are used as the score of that doc.
- /// Values are instantiated as
+ /// ValueSource implementations differ in RAM requirements: it would always be a factor
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSourceQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ValueSourceQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSourceQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ValueSourceQuery.cs Mon Dec 14 14:13:03 2009
@@ -27,15 +27,15 @@
///
+ ///
+ ///
+ ///
+ ///
/// WARNING: The status of the Search.Function package is experimental.
/// The APIs introduced here might change in the future and will not be
/// supported anymore in such a case.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FuzzyTermEnum.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs Mon Dec 14 14:13:03 2009
@@ -26,7 +26,7 @@
/// Term enumerations are always ordered by Term.compareTo(). Each term in
+ ///
+ ///
+ ///
+ /// Similarity returns a number that is 1.0f or less (including negative numbers)
+ /// Embedded within this algorithm is a fail-fast Levenshtein distance
+ /// To calculate the maximum distance threshold we use the following formula:
+ /// Levenshtein distance (also known as edit distance) is a measure of similiarity
+ /// If, for example, an application wished to collect all of the hits for a
+ /// Note: This is called in an inner search loop. For good search
+ /// Note: The NOTE: This class pre-allocate a full array of
+ ///
+ ///
+ /// Documents are cached, so that repeated requests for the same element may
+ ///
+ /// Applications usually need only call the inherited {@link #Search(Query)}
+ /// Note that you can only access Hits from an IndexSearcher as long as it is
+ ///
+ /// Applications usually need only call the inherited {@link #Search(Query)}
+ /// This query cannot be used directly; you must subclass
+ /// NOTE: if {@link #setRewriteMethod} is either
+ /// The recommended rewrite method is {@link
+ /// This method is faster than the BooleanQuery
+ /// NOTE: This rewrite method will hit {@link
+ /// NOTE: This rewrite method will hit {@link
+ /// This method is not thread safe, be sure to only call it when no query is running!
+ /// On optimized indexes / no MultiReaders, you get the correct number of
+ ///
+ ///
+ /// This method is not thread safe, be sure to only call it when no filter is running!
+ /// You create a new NumericRangeFilter with the static
+ /// NOTE: This API is experimental and
+ /// NOTE: This API is experimental and
/// might change in incompatible ways in the next
/// release.
///
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/NumericRangeQuery.cs?rev=890338&r1=890337&r2=890338&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs Mon Dec 14 14:13:03 2009
@@ -28,7 +28,7 @@
namespace Lucene.Net.Search
{
- /// A {@link Query} that matches numeric values within a
+ /// You create a new NumericRangeQuery with the static
+ /// The performance of NumericRangeQuery is much better
+ /// You can optionally specify a You can optionally specify a This query defaults to {@linkplain
+ /// NOTE: This API is experimental and
+ /// NOTE: This API is experimental and
/// might change in incompatible ways in the next release.
///
/// See the publication about panFMP,
+ /// A quote from this paper: Because Apache Lucene is a full-text
+ /// For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
+ /// You can choose any (this formula is only correct, when Good values for Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
+ ///
+ /// Applications usually need only call the inherited {@link #Search(Query)}
+ /// {@link Collector#Collect(int)} is called for every matching document.
+ /// Applications should only use this if they need all of the
+ ///
+ ///
+ ///
+ ///
+ /// This query may be combined with other terms or queries with a {@link BooleanQuery}.
+ /// The slop is in fact an edit-distance, where the units correspond to
+ /// More exact matches are scored higher than sloppier matches, thus search
+ /// The slop is zero by default, requiring exact matches.
+ /// This query uses the {@link
+ ///
///
- ///
@@ -102,7 +102,7 @@
}
///
type param tells how to parse the field string values into a numeric score value.
/// getFloats() and makes those values
/// available as other numeric types, casting as needed.
///
- /// getInts() and makes those values
/// available as other numeric types, casting as needed.
///
- ///
If there were only three field values: "apple","banana","pear"
///
then ord("apple")=1, ord("banana")=2, ord("pear")=3
- ///
/// Example of reverse ordinal (rord):
///
If there were only three field values: "apple","banana","pear"
///
then rord("apple")=3, rord("banana")=2, ord("pear")=1
- /// getShorts() and makes those values
/// available as other numeric types, casting as needed.
///
- /// reader which share a prefix of
/// length prefixLength with term and which have a fuzzy similarity >
/// minSimilarity.
- ///
@@ -196,12 +196,12 @@
/// prefix that are identical and editDistance is the Levenshtein distance for
/// the two words.
/// (1 - minimumSimilarity) * length
/// where length is the shortest term including any prefix that is not part of the
@@ -212,7 +212,7 @@
/// return (similarity > minimumSimilarity);
/// where distance is the Levenshtein distance for the two words.
///
/// Searcher searcher = new IndexSearcher(indexReader);
/// final BitSet bits = new BitSet(indexReader.maxDoc());
@@ -49,13 +49,13 @@
/// });
///
///
- /// score passed to this method is a raw score.
+ /// score passed to this method is a raw score.
/// In other words, the score will not necessarily be a float whose value is
/// between 0 and 1.
/// size.
///
/// IndexSearcher} instances are completely
/// thread safe, meaning multiple threads can call any of its
/// methods, concurrently. If your application requires
@@ -200,7 +200,7 @@
/// whether or not the fields in the returned {@link FieldDoc} instances
/// should be set by specifying fillFields.
///
- /// Searchables.
///
- /// MultiTermQueryWrapperFilter is not designed to
/// be used by itself. Normally you subclass it to provide a Filter
/// counterpart for a {@link MultiTermQuery} subclass.
- /// MultiTermQueryWrapperFilter.
/// This class also provides the functionality behind
@@ -134,7 +134,7 @@
///
@@ -43,7 +43,7 @@
/// See {@link NumericRangeQuery} for details on how Lucene
/// indexes and searches numeric valued fields.
///
- ///
@@ -48,12 +48,12 @@
/// matches all documents whose float valued "weight" field
/// ranges from 0.3 to 0.10, inclusive.
///
- ///
precisionStep
/// when creating this query. This is necessary if you've
/// changed this configuration from its default (4) during
@@ -64,7 +64,7 @@
/// classes. See below for
/// details.
///
- /// How it works
///
- /// TrieRangeQuery):
///
/// Schindler, U, Diepenbroek, M, 2008.
@@ -89,7 +89,7 @@
/// doi:10.1016/j.cageo.2008.02.023
///
- /// 7*255*2 + 255 = 3825 distinct terms (when there is a term for every distinct value of an
@@ -111,14 +111,14 @@
/// and a uniform value distribution).Precision Step
- /// precisionStep when encoding values.
+ /// precisionStep when encoding values.
/// Lower step values mean more precisions and so more terms in index (and index gets larger).
/// On the other hand, the maximum number of terms to match reduces, which optimized query speed.
/// The formula to calculate the maximum term count is:
///
/// n = [ (bitsPerValue/precisionStep - 1) * (2^precisionStep - 1 ) * 2 ] + (2^precisionStep - 1 )
///
- /// bitsPerValue/precisionStep is an integer;
+ /// (this formula is only correct, when bitsPerValue/precisionStep is an integer;
/// in other cases, the value must be rounded up and the last summand must contain the modulo of the division as
/// precision step).
/// For longs stored using a precision step of 4, n = 15*15*2 + 15 = 465, and for a precision
@@ -127,7 +127,7 @@
/// be found out by testing. Important: You can index with a lower precision step value and test search speed
/// using a multiple of the original step value.precisionStep are depending on usage and data type:
+ /// precisionStep are depending on usage and data type:
///
///
///
- /// precisionStep is given.
/// precisionSteps.
/// Searchables.
///
- /// "new york".
///
- /// WITHIN or NEAR operator.
- /// app*.
///
- ///