Similarity.cs

Go to the documentation of this file.

/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

using System;
using System.Collections.Generic;
using Lucene.Net.Documents;
using FieldInvertState = Lucene.Net.Index.FieldInvertState;
using Term = Lucene.Net.Index.Term;
using SmallFloat = Lucene.Net.Util.SmallFloat;
using IDFExplanation = Lucene.Net.Search.Explanation.IDFExplanation;

namespace Lucene.Net.Search
{
    
    [Serializable]
    public abstract class Similarity
    {
        protected Similarity()
        {
            InitBlock();
        }
        [Serializable]
        private class AnonymousClassIDFExplanation1:IDFExplanation
        {
            public AnonymousClassIDFExplanation1(int df, int max, float idf, Similarity enclosingInstance)
            {
                InitBlock(df, max, idf, enclosingInstance);
            }
            private void  InitBlock(int df, int max, float idf, Similarity enclosingInstance)
            {
                this.df = df;
                this.max = max;
                this.idf = idf;
                this.enclosingInstance = enclosingInstance;
            }
            private int df;
            private int max;
            private float idf;
            private Similarity enclosingInstance;
            public Similarity Enclosing_Instance
            {
                get
                {
                    return enclosingInstance;
                }
                
            }
            //@Override
            public override System.String Explain()
            {
                return "idf(docFreq=" + df + ", maxDocs=" + max + ")";
            }
            //@Override

            public override float Idf
            {
                get { return idf; }
            }
        }
        [Serializable]
        private class AnonymousClassIDFExplanation3:IDFExplanation
        {
            public AnonymousClassIDFExplanation3(float fIdf, System.Text.StringBuilder exp, Similarity enclosingInstance)
            {
                InitBlock(fIdf, exp, enclosingInstance);
            }
            private void  InitBlock(float fIdf, System.Text.StringBuilder exp, Similarity enclosingInstance)
            {
                this.fIdf = fIdf;
                this.exp = exp;
                this.enclosingInstance = enclosingInstance;
            }
            private float fIdf;
            private System.Text.StringBuilder exp;
            private Similarity enclosingInstance;
            public Similarity Enclosing_Instance
            {
                get
                {
                    return enclosingInstance;
                }
                
            }
            //@Override

            public override float Idf
            {
                get { return fIdf; }
            }

            //@Override
            public override System.String Explain()
            {
                return exp.ToString();
            }
        }
        private void  InitBlock()
        {
            
        }

        private static Similarity defaultImpl = new DefaultSimilarity();
        public const int NO_DOC_ID_PROVIDED = - 1;

        public static Similarity Default
        {
            get { return defaultImpl; }
            set { defaultImpl = value; }
        }

        private static readonly float[] NORM_TABLE = new float[256];
        
        public static float DecodeNorm(byte b)
        {
            return NORM_TABLE[b & 0xFF]; // & 0xFF maps negative bytes to positive above 127
        }

        public static float[] GetNormDecoder()
        {
            return NORM_TABLE;
        }

        public virtual float ComputeNorm(System.String field, FieldInvertState state)
        {
            return (float) (state.Boost * LengthNorm(field, state.Length));
        }
        
        public abstract float LengthNorm(System.String fieldName, int numTokens);
        
        public abstract float QueryNorm(float sumOfSquaredWeights);
        
        public static byte EncodeNorm(float f)
        {
            return (byte) SmallFloat.FloatToByte315(f);
        }
        
        
        public virtual float Tf(int freq)
        {
            return Tf((float) freq);
        }
        
        public abstract float SloppyFreq(int distance);
        
        public abstract float Tf(float freq);
        
        public virtual IDFExplanation IdfExplain(Term term, Searcher searcher)
        {
            int df = searcher.DocFreq(term);
            int max = searcher.MaxDoc;
            float idf2 = Idf(df, max);
            return new AnonymousClassIDFExplanation1(df, max, idf2, this);
        }
        
        public virtual IDFExplanation IdfExplain(ICollection<Term> terms, Searcher searcher)
        {
            int max = searcher.MaxDoc;
            float idf2 = 0.0f;
            System.Text.StringBuilder exp = new System.Text.StringBuilder();
            foreach (Term term in terms)
            {
                int df = searcher.DocFreq(term);
                idf2 += Idf(df, max);
                exp.Append(" ");
                exp.Append(term.Text);
                exp.Append("=");
                exp.Append(df);
            }
            float fIdf = idf2;
            return new AnonymousClassIDFExplanation3(fIdf, exp, this);
        }
        
        public abstract float Idf(int docFreq, int numDocs);
        
        public abstract float Coord(int overlap, int maxOverlap);
        
        
        public virtual float ScorePayload(int docId, System.String fieldName, int start, int end, byte[] payload, int offset, int length)
        {
            return 1;
        }

        static Similarity()
        {
            {
                for (int i = 0; i < 256; i++)
                    NORM_TABLE[i] = SmallFloat.Byte315ToFloat((byte) i);
            }
        }
    }
}