org.apache.lucene.search.similarities

Class ClassicSimilarity

  • Direct Known Subclasses:
    SweetSpotSimilarity


    public class ClassicSimilarity
    extends TFIDFSimilarity
    Expert: Default scoring implementation which encodes norm values as a single byte before being stored. At search time, the norm byte value is read from the index directory and decoded back to a float norm value. This encoding/decoding, while reducing index size, comes with the price of precision loss - it is not guaranteed that decode(encode(x)) = x. For instance, decode(encode(0.89)) = 0.875.

    Compression of norm values to a single byte saves memory at search time, because once a field is referenced at search time, its norms - for all documents - are maintained in memory.

    The rationale supporting such lossy compression of norm values is that given the difficulty (and inaccuracy) of users to express their true information need by a query, only big differences matter.
     
    Last, note that search time is too late to modify this norm part of scoring, e.g. by using a different Similarity for search.

    • Field Detail

      • discountOverlaps

        protected boolean discountOverlaps
        True if overlap tokens (tokens with a position of increment of zero) are discounted from the document's length.
    • Constructor Detail

    • Method Detail

      • coord

        public float coord(int overlap,
                           int maxOverlap)
        Implemented as overlap / maxOverlap.
        Specified by:
        coord in class TFIDFSimilarity
        Parameters:
        overlap - the number of query terms matched in the document
        maxOverlap - the total number of terms in the query
        Returns:
        a score factor based on term overlap with the query
      • queryNorm

        public float queryNorm(float sumOfSquaredWeights)
        Implemented as 1/sqrt(sumOfSquaredWeights).
        Specified by:
        queryNorm in class TFIDFSimilarity
        Parameters:
        sumOfSquaredWeights - the sum of the squares of query term weights
        Returns:
        a normalization factor for query weights
      • encodeNormValue

        public final long encodeNormValue(float f)
        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.

        Specified by:
        encodeNormValue in class TFIDFSimilarity
        See Also:
        Field.setBoost(float), SmallFloat
      • tf

        public float tf(float freq)
        Implemented as sqrt(freq).
        Specified by:
        tf in class TFIDFSimilarity
        Parameters:
        freq - the frequency of a term within a document
        Returns:
        a score factor based on a term's within-document frequency
      • sloppyFreq

        public float sloppyFreq(int distance)
        Implemented as 1 / (distance + 1).
        Specified by:
        sloppyFreq in class TFIDFSimilarity
        Parameters:
        distance - the edit distance of this sloppy phrase match
        Returns:
        the frequency increment for this match
        See Also:
        PhraseQuery.getSlop()
      • scorePayload

        public float scorePayload(int doc,
                                  int start,
                                  int end,
                                  BytesRef payload)
        The default implementation returns 1
        Specified by:
        scorePayload in class TFIDFSimilarity
        Parameters:
        doc - The docId currently being scored.
        start - The start position of the payload
        end - The end position of the payload
        payload - The payload byte array to be scored
        Returns:
        An implementation dependent float to be used as a scoring factor
      • idf

        public float idf(long docFreq,
                         long docCount)
        Implemented as log((docCount+1)/(docFreq+1)) + 1.
        Specified by:
        idf in class TFIDFSimilarity
        Parameters:
        docFreq - the number of documents which contain the term
        docCount - the total number of documents in the collection
        Returns:
        a score factor based on the term's document frequency