You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by ho...@apache.org on 2015/11/05 22:31:16 UTC

svn commit: r1712868 - in /lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities: ClassicSimilarity.java DefaultSimilarity.java

Author: hossman
Date: Thu Nov  5 21:31:16 2015
New Revision: 1712868

URL: http://svn.apache.org/viewvc?rev=1712868&view=rev
Log:
LUCENE-6887: DefaultSimilarity is deprecated, use ClassicSimilarity for equivilent behavior, or consider switching to BM25Similarity which will become the new default in Lucene 6.0

Added:
    lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/ClassicSimilarity.java
      - copied, changed from r1712835, lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/DefaultSimilarity.java
Modified:
    lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/DefaultSimilarity.java

Copied: lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/ClassicSimilarity.java (from r1712835, lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/DefaultSimilarity.java)
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/ClassicSimilarity.java?p2=lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/ClassicSimilarity.java&p1=lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/DefaultSimilarity.java&r1=1712835&r2=1712868&rev=1712868&view=diff
==============================================================================
--- lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/DefaultSimilarity.java (original)
+++ lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/ClassicSimilarity.java Thu Nov  5 21:31:16 2015
@@ -42,7 +42,7 @@ import org.apache.lucene.util.SmallFloat
  * Last, note that search time is too late to modify this <i>norm</i> part of
  * scoring, e.g. by using a different {@link Similarity} for search.
  */
-public class DefaultSimilarity extends TFIDFSimilarity {
+public class ClassicSimilarity extends TFIDFSimilarity {
   
   /** Cache of decoded bytes. */
   private static final float[] NORM_TABLE = new float[256];
@@ -54,7 +54,7 @@ public class DefaultSimilarity extends T
   }
 
   /** Sole constructor: parameter-free */
-  public DefaultSimilarity() {}
+  public ClassicSimilarity() {}
   
   /** Implemented as <code>overlap / maxOverlap</code>. */
   @Override

Modified: lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/DefaultSimilarity.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/DefaultSimilarity.java?rev=1712868&r1=1712867&r2=1712868&view=diff
==============================================================================
--- lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/DefaultSimilarity.java (original)
+++ lucene/dev/branches/branch_5x/lucene/core/src/java/org/apache/lucene/search/similarities/DefaultSimilarity.java Thu Nov  5 21:31:16 2015
@@ -22,152 +22,14 @@ import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.SmallFloat;
 
 /**
- * Expert: Default scoring implementation which {@link #encodeNormValue(float)
- * encodes} norm values as a single byte before being stored. At search time,
- * the norm byte value is read from the index
- * {@link org.apache.lucene.store.Directory directory} and
- * {@link #decodeNormValue(long) decoded} back to a float <i>norm</i> value.
- * This encoding/decoding, while reducing index size, comes with the price of
- * precision loss - it is not guaranteed that <i>decode(encode(x)) = x</i>. For
- * instance, <i>decode(encode(0.89)) = 0.875</i>.
- * <p>
- * 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.
- * <p>
- * 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. <br>
- * &nbsp;<br>
- * Last, note that search time is too late to modify this <i>norm</i> part of
- * scoring, e.g. by using a different {@link Similarity} for search.
+ * Expert: Default scoring implementation - see superclass {@link ClassicSimilarity} for 
+ * implementation details.
+ *
+ * @deprecated Use {@link ClassicSimilarity} for equivilent behavior, or consider switching to {@link BM25Similarity} which will become the new default in Lucene 6.0
  */
-public class DefaultSimilarity extends TFIDFSimilarity {
+@Deprecated
+public class DefaultSimilarity extends ClassicSimilarity {
   
-  /** Cache of decoded bytes. */
-  private static final float[] NORM_TABLE = new float[256];
-
-  static {
-    for (int i = 0; i < 256; i++) {
-      NORM_TABLE[i] = SmallFloat.byte315ToFloat((byte)i);
-    }
-  }
-
-  /** Sole constructor: parameter-free */
-  public DefaultSimilarity() {}
-  
-  /** Implemented as <code>overlap / maxOverlap</code>. */
-  @Override
-  public float coord(int overlap, int maxOverlap) {
-    return overlap / (float)maxOverlap;
-  }
-
-  /** Implemented as <code>1/sqrt(sumOfSquaredWeights)</code>. */
-  @Override
-  public float queryNorm(float sumOfSquaredWeights) {
-    return (float)(1.0 / Math.sqrt(sumOfSquaredWeights));
-  }
-  
-  /**
-   * Encodes a normalization factor for storage in an index.
-   * <p>
-   * 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.
-   * 
-   * @see org.apache.lucene.document.Field#setBoost(float)
-   * @see org.apache.lucene.util.SmallFloat
-   */
-  @Override
-  public final long encodeNormValue(float f) {
-    return SmallFloat.floatToByte315(f);
-  }
-
-  /**
-   * Decodes the norm value, assuming it is a single byte.
-   * 
-   * @see #encodeNormValue(float)
-   */
-  @Override
-  public final float decodeNormValue(long norm) {
-    return NORM_TABLE[(int) (norm & 0xFF)];  // & 0xFF maps negative bytes to positive above 127
-  }
-
-  /** Implemented as
-   *  <code>state.getBoost()*lengthNorm(numTerms)</code>, where
-   *  <code>numTerms</code> is {@link FieldInvertState#getLength()} if {@link
-   *  #setDiscountOverlaps} is false, else it's {@link
-   *  FieldInvertState#getLength()} - {@link
-   *  FieldInvertState#getNumOverlap()}.
-   *
-   *  @lucene.experimental */
-  @Override
-  public float lengthNorm(FieldInvertState state) {
-    final int numTerms;
-    if (discountOverlaps)
-      numTerms = state.getLength() - state.getNumOverlap();
-    else
-      numTerms = state.getLength();
-    return state.getBoost() * ((float) (1.0 / Math.sqrt(numTerms)));
-  }
-
-  /** Implemented as <code>sqrt(freq)</code>. */
-  @Override
-  public float tf(float freq) {
-    return (float)Math.sqrt(freq);
-  }
-    
-  /** Implemented as <code>1 / (distance + 1)</code>. */
-  @Override
-  public float sloppyFreq(int distance) {
-    return 1.0f / (distance + 1);
-  }
+  /* trivial subclass for backcompat and deprecation */
   
-  /** The default implementation returns <code>1</code> */
-  @Override
-  public float scorePayload(int doc, int start, int end, BytesRef payload) {
-    return 1;
-  }
-
-  /** Implemented as <code>log(numDocs/(docFreq+1)) + 1</code>. */
-  @Override
-  public float idf(long docFreq, long numDocs) {
-    return (float)(Math.log(numDocs/(double)(docFreq+1)) + 1.0);
-  }
-    
-  /** 
-   * True if overlap tokens (tokens with a position of increment of zero) are
-   * discounted from the document's length.
-   */
-  protected boolean discountOverlaps = true;
-
-  /** Determines whether overlap tokens (Tokens with
-   *  0 position increment) are ignored when computing
-   *  norm.  By default this is true, meaning overlap
-   *  tokens do not count when computing norms.
-   *
-   *  @lucene.experimental
-   *
-   *  @see #computeNorm
-   */
-  public void setDiscountOverlaps(boolean v) {
-    discountOverlaps = v;
-  }
-
-  /**
-   * Returns true if overlap tokens are discounted from the document's length. 
-   * @see #setDiscountOverlaps 
-   */
-  public boolean getDiscountOverlaps() {
-    return discountOverlaps;
-  }
-
-  @Override
-  public String toString() {
-    return "DefaultSimilarity";
-  }
 }