C# Class Lucene.Net.Search.Similarity

ファイルを表示 Open project: synhershko/lucene.net Class Usage Examples

Public Methods

Method	Description
ComputeNorm ( System field, Lucene.Net.Index.FieldInvertState state ) : float	Compute the normalization value for a field, given the accumulated state of term processing for this field (see 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 LengthNorm(String, int) passing FieldInvertState.GetLength() as the second argument, and then multiplies this value by FieldInvertState.GetBoost(). WARNING: This API is new and experimental and may suddenly change.
Coord ( int overlap, int maxOverlap ) : float	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.
DecodeNorm ( byte b ) : float	Decodes a normalization factor stored in an index.
EncodeNorm ( float f ) : byte	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.
GetNormDecoder ( ) : float[]	Returns a table for decoding normalization bytes.
Idf ( int docFreq, int numDocs ) : float	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 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.
IdfExplain ( ICollection terms, Searcher searcher ) : Lucene.Net.Search.Explanation.IDFExplanation	Computes a score factor for a phrase. The default implementation sums the idf factor for each term in the phrase.
IdfExplain ( Lucene.Net.Index.Term term, Searcher searcher ) : Lucene.Net.Search.Explanation.IDFExplanation	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 Searcher.MaxDoc is used instead of Lucene.Net.Index.IndexReader.NumDocs() because it is proportional to Searcher.DocFreq(Term) , i.e., when one is inaccurate, so is the other, and in the same direction.
LengthNorm ( System fieldName, int numTokens ) : float	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 `numTokens` is large, and larger values when `numTokens` is small. Note that the return values are computed under Lucene.Net.Index.IndexWriter.AddDocument(Lucene.Net.Documents.Document) and then stored using EncodeNorm(float). Thus they have limited precision, and documents must be re-indexed if this method is altered.
QueryNorm ( float sumOfSquaredWeights ) : float	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.
ScorePayload ( int docId, System fieldName, int start, int end, byte payload, int offset, int length ) : float	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.
SloppyFreq ( int distance ) : float	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 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.
Tf ( float freq ) : float	Computes a score factor based on a term or phrase's frequency in a document. This value is multiplied by the Idf(int, int) 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 `freq` is large, and smaller values when `freq` is small.
Tf ( int freq ) : float	Computes a score factor based on a term or phrase's frequency in a document. This value is multiplied by the Idf(int, int) 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 `freq` is large, and smaller values when `freq` is small. The default implementation calls Tf(float).

Protected Methods

Method	Description
Similarity ( ) : System

Private Methods

Method	Description
InitBlock ( ) : void

Method Details

ComputeNorm() public method

Compute the normalization value for a field, given the accumulated state of term processing for this field (see 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 LengthNorm(String, int) passing FieldInvertState.GetLength() as the second argument, and then multiplies this value by FieldInvertState.GetBoost().

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

public ComputeNorm ( System field, Lucene.Net.Index.FieldInvertState state ) : float
field	System	field name ///
state	Lucene.Net.Index.FieldInvertState	current processing state for this field ///
return	float

Coord() public abstract method

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 abstract Coord ( int overlap, int maxOverlap ) : float
overlap	int	the number of query terms matched in the document ///
maxOverlap	int	the total number of terms in the query ///
return	float

DecodeNorm() public static method

Decodes a normalization factor stored in an index.

public static DecodeNorm ( byte b ) : float
b	byte
return	float

EncodeNorm() public static method

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 static EncodeNorm ( float f ) : byte
f	float
return	byte

GetNormDecoder() public static method

Returns a table for decoding normalization bytes.

public static GetNormDecoder ( ) : float[]
return	float[]

Idf() public abstract method

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 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 abstract Idf ( int docFreq, int numDocs ) : float
docFreq	int	the number of documents which contain the term ///
numDocs	int	the total number of documents in the collection ///
return	float

IdfExplain() public method

Computes a score factor for a phrase.

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

public IdfExplain ( ICollection terms, Searcher searcher ) : Lucene.Net.Search.Explanation.IDFExplanation
terms	ICollection	the terms in the phrase ///
searcher	Searcher	the document collection being searched ///
return	Lucene.Net.Search.Explanation.IDFExplanation

IdfExplain() public method

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 Searcher.MaxDoc is used instead of Lucene.Net.Index.IndexReader.NumDocs() because it is proportional to Searcher.DocFreq(Term) , i.e., when one is inaccurate, so is the other, and in the same direction.

public IdfExplain ( Lucene.Net.Index.Term term, Searcher searcher ) : Lucene.Net.Search.Explanation.IDFExplanation
term	Lucene.Net.Index.Term	the term in question ///
searcher	Searcher	the document collection being searched ///
return	Lucene.Net.Search.Explanation.IDFExplanation

LengthNorm() public abstract method

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 numTokens is large, and larger values when numTokens is small.

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

public abstract LengthNorm ( System fieldName, int numTokens ) : float
fieldName	System	the name of the field ///
numTokens	int	the total number of tokens contained in fields named /// fieldName of doc. ///
return	float

QueryNorm() public abstract method

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 abstract QueryNorm ( float sumOfSquaredWeights ) : float
sumOfSquaredWeights	float	the sum of the squares of query term weights ///
return	float

ScorePayload() public method

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 ScorePayload ( int docId, System fieldName, int start, int end, byte payload, int offset, int length ) : float
docId	int	The docId currently being scored. If this value is , then it should be assumed that the PayloadQuery implementation does not provide document information ///
fieldName	System	The fieldName of the term this payload belongs to ///
start	int	The start position of the payload ///
end	int	The end position of the payload ///
payload	byte	The payload byte array to be scored ///
offset	int	The offset into the payload array ///
length	int	The length in the array ///
return	float

Similarity() protected method

protected Similarity ( ) : System
return	System

SloppyFreq() public abstract method

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 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 abstract SloppyFreq ( int distance ) : float
distance	int	the edit distance of this sloppy phrase match ///
return	float

Tf() public abstract method

Computes a score factor based on a term or phrase's frequency in a document. This value is multiplied by the Idf(int, int) 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 freq is large, and smaller values when freq is small.

public abstract Tf ( float freq ) : float
freq	float	the frequency of a term within a document ///
return	float

Tf() public method

The default implementation calls Tf(float).

public Tf ( int freq ) : float
freq	int	the frequency of a term within a document ///
return	float