The Similarity type exposes the following members.

Constructors

  NameDescription
Public methodSimilarity
Initializes a new instance of the Similarity class

Methods

  NameDescription
Public methodComputeNorm
Compute the normalization value for a field, given the accumulated state of term processing for this field (see {@link FieldInvertState}).

Implementations should calculate a float value based on the field state and then return that value.

For backward compatibility this method by default calls {@link #LengthNorm(String, int)} passing {@link FieldInvertState#GetLength()} as the second argument, and then multiplies this value by {@link FieldInvertState#GetBoost()}.

WARNING: This API is new and experimental and may suddenly change.

Public methodCoord
Computes a score factor based on the fraction of all query terms that a document contains. This value is multiplied into scores.

The presence of a large portion of the query terms indicates a better match with the query, so implementations of this method usually return larger values when the ratio between these parameters is large and smaller values when the ratio between them is small.

Public methodStatic memberDecodeNorm
Decodes a normalization factor stored in an index.
Public methodStatic memberEncodeNorm
Encodes a normalization factor for storage in an index.

The encoding uses a three-bit mantissa, a five-bit exponent, and the zero-exponent point at 15, thus representing values from around 7x10^9 to 2x10^-9 with about one significant decimal digit of accuracy. Zero is also represented. Negative numbers are rounded up to zero. Values too large to represent are rounded down to the largest representable value. Positive values too small to represent are rounded up to the smallest positive representable value.

Public methodEquals
Determines whether the specified Object is equal to the current Object.
(Inherited from Object.)
Protected methodFinalize
Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.
(Inherited from Object.)
Public methodStatic memberGetDefault
Return the default Similarity implementation used by indexing and search code.

This is initially an instance of {@link DefaultSimilarity}.

Public methodGetHashCode
Serves as a hash function for a particular type.
(Inherited from Object.)
Public methodStatic memberGetNormDecoder
Returns a table for decoding normalization bytes.
Public methodGetType
Gets the Type of the current instance.
(Inherited from Object.)
Public methodIdf(ICollection, Searcher) Obsolete.
Computes a score factor for a phrase.

The default implementation sums the {@link #Idf(Term,Searcher)} factor for each term in the phrase.

Public methodIdf(Int32, Int32)
Computes a score factor based on a term's document frequency (the number of documents which contain the term). This value is multiplied by the {@link #Tf(int)} factor for each term in the query and these products are then summed to form the initial score for a document.

Terms that occur in fewer documents are better indicators of topic, so implementations of this method usually return larger values for rare terms, and smaller values for common terms.

Public methodIdf(Term, Searcher) Obsolete.
Computes a score factor for a simple term.

The default implementation is:

            return idf(searcher.docFreq(term), searcher.maxDoc());
            
Note that {@link Searcher#MaxDoc()} is used instead of {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is proportional to {@link Searcher#DocFreq(Term)} , i.e., when one is inaccurate, so is the other, and in the same direction.
Public methodidfExplain
Computes a score factor for a phrase.

The default implementation sums the idf factor for each term in the phrase.

Public methodIdfExplain
Computes a score factor for a simple term and returns an explanation for that score factor.

The default implementation uses:

            idf(searcher.docFreq(term), searcher.maxDoc());
            
Note that {@link Searcher#MaxDoc()} is used instead of {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is proportional to {@link Searcher#DocFreq(Term)} , i.e., when one is inaccurate, so is the other, and in the same direction.
Public methodLengthNorm
Computes the normalization value for a field given the total number of terms contained in a field. These values, together with field boosts, are stored in an index and multipled into scores for hits on each field by the search code.

Matches in longer fields are less precise, so implementations of this method usually return smaller values when

CopyC#
numTokens
is large, and larger values when
CopyC#
numTokens
is small.

Note that the return values are computed under {@link Lucene.Net.Index.IndexWriter#AddDocument(Lucene.Net.Documents.Document)} and then stored using {@link #EncodeNorm(float)}. Thus they have limited precision, and documents must be re-indexed if this method is altered.

Protected methodMemberwiseClone
Creates a shallow copy of the current Object.
(Inherited from Object.)
Public methodQueryNorm
Computes the normalization value for a query given the sum of the squared weights of each of the query terms. This value is then multipled into the weight of each query term.

This does not affect ranking, but rather just attempts to make scores from different queries comparable.

Public methodScorePayload(String, array<Byte>[]()[][], Int32, Int32) Obsolete.
Calculate a scoring factor based on the data in the payload. Overriding implementations are responsible for interpreting what is in the payload. Lucene makes no assumptions about what is in the byte array.

The default implementation returns 1.

Public methodScorePayload(Int32, String, Int32, Int32, array<Byte>[]()[][], Int32, Int32)
Calculate a scoring factor based on the data in the payload. Overriding implementations are responsible for interpreting what is in the payload. Lucene makes no assumptions about what is in the byte array.

The default implementation returns 1.

Public methodStatic memberSetDefault
Set the default Similarity implementation used by indexing and search code.
Public methodSloppyFreq
Computes the amount of a sloppy phrase match, based on an edit distance. This value is summed for each sloppy phrase match in a document to form the frequency that is passed to {@link #Tf(float)}.

A phrase match with a small edit distance to a document passage more closely matches the document, so implementations of this method usually return larger values when the edit distance is small and smaller values when it is large.

Public methodTf(Int32)
Computes a score factor based on a term or phrase's frequency in a document. This value is multiplied by the {@link #Idf(Term, Searcher)} factor for each term in the query and these products are then summed to form the initial score for a document.

Terms and phrases repeated in a document indicate the topic of the document, so implementations of this method usually return larger values when

CopyC#
freq
is large, and smaller values when
CopyC#
freq
is small.

The default implementation calls {@link #Tf(float)}.

Public methodTf(Single)
Computes a score factor based on a term or phrase's frequency in a document. This value is multiplied by the {@link #Idf(Term, Searcher)} factor for each term in the query and these products are then summed to form the initial score for a document.

Terms and phrases repeated in a document indicate the topic of the document, so implementations of this method usually return larger values when

CopyC#
freq
is large, and smaller values when
CopyC#
freq
is small.
Public methodToString
Returns a String that represents the current Object.
(Inherited from Object.)

Fields

  NameDescription
Public fieldStatic memberNO_DOC_ID_PROVIDED

See Also