lucene-java-3.5.0/lucene/contrib/misc/src/test/org/apache/lucene/misc/SweetSpotSimilarityTest.java

   1
   2 /**
   3  * Licensed to the Apache Software Foundation (ASF) under one or more
   4  * contributor license agreements.  See the NOTICE file distributed with
   5  * this work for additional information regarding copyright ownership.
   6  * The ASF licenses this file to You under the Apache License, Version 2.0
   7  * (the "License"); you may not use this file except in compliance with
   8  * the License.  You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 package org.apache.lucene.misc;
  20
  21 import org.apache.lucene.search.DefaultSimilarity;
  22 import org.apache.lucene.search.Similarity;
  23 import org.apache.lucene.util.LuceneTestCase;
  24 import org.apache.lucene.index.FieldInvertState;
  25
  26 /**
  27  * Test of the SweetSpotSimilarity
  28  */
  29 public class SweetSpotSimilarityTest extends LuceneTestCase {
  30
  31   public void testSweetSpotComputeNorm() {
  32
  33     SweetSpotSimilarity ss = new SweetSpotSimilarity();
  34     ss.setLengthNormFactors(1,1,0.5f);
  35
  36     Similarity d = new DefaultSimilarity();
  37     Similarity s = ss;
  38
  39
  40     // base case, should degrade
  41     final FieldInvertState invertState = new FieldInvertState();
  42     invertState.setBoost(1.0f);
  43     for (int i = 1; i < 1000; i++) {
  44       invertState.setLength(i);
  45       assertEquals("base case: i="+i,
  46                    d.computeNorm("foo", invertState),
  47                    s.computeNorm("foo", invertState),
  48                    0.0f);
  49     }
  50
  51     // make a sweet spot
  52
  53     ss.setLengthNormFactors(3,10,0.5f);
  54
  55     for (int i = 3; i <=10; i++) {
  56       invertState.setLength(i);
  57       assertEquals("3,10: spot i="+i,
  58                    1.0f,
  59                    s.computeNorm("foo", invertState),
  60                    0.0f);
  61     }
  62
  63     for (int i = 10; i < 1000; i++) {
  64       invertState.setLength(i-9);
  65       final float normD = d.computeNorm("foo", invertState);
  66       invertState.setLength(i);
  67       final float normS = s.computeNorm("foo", invertState);
  68       assertEquals("3,10: 10<x : i="+i,
  69                    normD,
  70                    normS,
  71                    0.0f);
  72     }
  73
  74
  75     // seperate sweet spot for certain fields
  76
  77     ss.setLengthNormFactors("bar",8,13, 0.5f, false);
  78     ss.setLengthNormFactors("yak",6,9, 0.5f, false);
  79
  80
  81     for (int i = 3; i <=10; i++) {
  82       invertState.setLength(i);
  83       assertEquals("f: 3,10: spot i="+i,
  84                    1.0f,
  85                    s.computeNorm("foo", invertState),
  86                    0.0f);
  87     }
  88     for (int i = 10; i < 1000; i++) {
  89       invertState.setLength(i-9);
  90       final float normD = d.computeNorm("foo", invertState);
  91       invertState.setLength(i);
  92       final float normS = s.computeNorm("foo", invertState);
  93       assertEquals("f: 3,10: 10<x : i="+i,
  94                    normD,
  95                    normS,
  96                    0.0f);
  97     }
  98     for (int i = 8; i <=13; i++) {
  99       invertState.setLength(i);
 100       assertEquals("f: 8,13: spot i="+i,
 101                    1.0f,
 102                    s.computeNorm("bar", invertState),
 103                    0.0f);
 104     }
 105     for (int i = 6; i <=9; i++) {
 106       invertState.setLength(i);
 107       assertEquals("f: 6,9: spot i="+i,
 108                    1.0f,
 109                    s.computeNorm("yak", invertState),
 110                    0.0f);
 111     }
 112     for (int i = 13; i < 1000; i++) {
 113       invertState.setLength(i-12);
 114       final float normD = d.computeNorm("foo", invertState);
 115       invertState.setLength(i);
 116       final float normS = s.computeNorm("bar", invertState);
 117       assertEquals("f: 8,13: 13<x : i="+i,
 118                    normD,
 119                    normS,
 120                    0.0f);
 121     }
 122     for (int i = 9; i < 1000; i++) {
 123       invertState.setLength(i-8);
 124       final float normD = d.computeNorm("foo", invertState);
 125       invertState.setLength(i);
 126       final float normS = s.computeNorm("yak", invertState);
 127       assertEquals("f: 6,9: 9<x : i="+i,
 128                    normD,
 129                    normS,
 130                    0.0f);
 131     }
 132
 133
 134     // steepness
 135
 136     ss.setLengthNormFactors("a",5,8,0.5f, false);
 137     ss.setLengthNormFactors("b",5,8,0.1f, false);
 138
 139     for (int i = 9; i < 1000; i++) {
 140       invertState.setLength(i);
 141       final float normSS = ss.computeNorm("a", invertState);
 142       final float normS = s.computeNorm("b", invertState);
 143       assertTrue("s: i="+i+" : a="+normSS+
 144                  " < b="+normS,
 145                  normSS < normS);
 146     }
 147
 148   }
 149
 150   public void testSweetSpotTf() {
 151
 152     SweetSpotSimilarity ss = new SweetSpotSimilarity();
 153
 154     Similarity d = new DefaultSimilarity();
 155     Similarity s = ss;
 156
 157     // tf equal
 158
 159     ss.setBaselineTfFactors(0.0f, 0.0f);
 160
 161     for (int i = 1; i < 1000; i++) {
 162       assertEquals("tf: i="+i,
 163                    d.tf(i), s.tf(i), 0.0f);
 164     }
 165
 166     // tf higher
 167
 168     ss.setBaselineTfFactors(1.0f, 0.0f);
 169
 170     for (int i = 1; i < 1000; i++) {
 171       assertTrue("tf: i="+i+" : d="+d.tf(i)+
 172                  " < s="+s.tf(i),
 173                  d.tf(i) < s.tf(i));
 174     }
 175
 176     // tf flat
 177
 178     ss.setBaselineTfFactors(1.0f, 6.0f);
 179     for (int i = 1; i <=6; i++) {
 180       assertEquals("tf flat1: i="+i, 1.0f, s.tf(i), 0.0f);
 181     }
 182     ss.setBaselineTfFactors(2.0f, 6.0f);
 183     for (int i = 1; i <=6; i++) {
 184       assertEquals("tf flat2: i="+i, 2.0f, s.tf(i), 0.0f);
 185     }
 186     for (int i = 6; i <=1000; i++) {
 187       assertTrue("tf: i="+i+" : s="+s.tf(i)+
 188                  " < d="+d.tf(i),
 189                  s.tf(i) < d.tf(i));
 190     }
 191
 192     // stupidity
 193     assertEquals("tf zero", 0.0f, s.tf(0), 0.0f);
 194   }
 195
 196   public void testHyperbolicSweetSpot() {
 197
 198     SweetSpotSimilarity ss = new SweetSpotSimilarity() {
 199         @Override
 200         public float tf(int freq) {
 201           return hyperbolicTf(freq);
 202         }
 203       };
 204     ss.setHyperbolicTfFactors(3.3f, 7.7f, Math.E, 5.0f);
 205
 206     Similarity s = ss;
 207
 208     for (int i = 1; i <=1000; i++) {
 209       assertTrue("MIN tf: i="+i+" : s="+s.tf(i),
 210                  3.3f <= s.tf(i));
 211       assertTrue("MAX tf: i="+i+" : s="+s.tf(i),
 212                  s.tf(i) <= 7.7f);
 213     }
 214     assertEquals("MID tf", 3.3f+(7.7f - 3.3f)/2.0f, s.tf(5), 0.00001f);
 215
 216     // stupidity
 217     assertEquals("tf zero", 0.0f, s.tf(0), 0.0f);
 218
 219   }
 220
 221
 222 }
 223