C# Class Lucene.Net.Search.Similarity

Afficher le fichier Open project: synhershko/lucene.net Class Usage Examples

Méthodes publiques

Méthode	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).

Méthodes protégées

Méthode	Description
Similarity ( ) : System

Private Methods

Méthode	Description
InitBlock ( ) : void

Method Details

ComputeNorm() public méthode

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 ///
Résultat	float

Coord() public abstract méthode

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 ///
Résultat	float

DecodeNorm() public static méthode

Decodes a normalization factor stored in an index.

public static DecodeNorm ( byte b ) : float
b	byte
Résultat	float

EncodeNorm() public static méthode

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
Résultat	byte

GetNormDecoder() public static méthode

Returns a table for decoding normalization bytes.

public static GetNormDecoder ( ) : float[]
Résultat	float[]

Idf() public abstract méthode

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 ///
Résultat	float

IdfExplain() public méthode

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 ///
Résultat	Lucene.Net.Search.Explanation.IDFExplanation

IdfExplain() public méthode

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 ///
Résultat	Lucene.Net.Search.Explanation.IDFExplanation

LengthNorm() public abstract méthode

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. ///
Résultat	float

QueryNorm() public abstract méthode

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 ///
Résultat	float

ScorePayload() public méthode

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 ///
Résultat	float

Similarity() protected méthode

protected Similarity ( ) : System
Résultat	System

SloppyFreq() public abstract méthode

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 ///
Résultat	float

Tf() public abstract méthode

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 ///
Résultat	float

Tf() public méthode

The default implementation calls Tf(float).

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