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>
- * <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";
- }
}