StructQryDocRep.hpp

Go to the documentation of this file.

/*==========================================================================
 * Copyright (c) 2002 University of Massachusetts.  All Rights Reserved.
 *
 * Use of the Lemur Toolkit for Language Modeling and Information Retrieval
 * is subject to the terms of the software license set forth in the LICENSE
 * file included with this software, and also available at
 * http://www.lemurproject.org/license.html
 *
 *==========================================================================
 */

#ifndef _STRUCTQRYDOCREP_HPP
#define _STRUCTQRYDOCREP_HPP
#include "DocumentRep.hpp"
#include <cmath>

namespace lemur 
{
  namespace retrieval
  {
    
    class StructQryDocRep : public lemur::api::DocumentRep {
    public:
      StructQryDocRep(lemur::api::DOCID_T docID, double *idfValue, int docLength, int docCount,
                      double docLengthAverage, double db) : 
        lemur::api::DocumentRep(docID), did(docID), idf(idfValue), end(docLength),
        docEnd(docLength), size(docLength), start(0),
        dla(docLengthAverage), defaultBelief(db) {
        oneMinusDB = 1 - defaultBelief;
        denom = log(docCount + 1.0);
        numer = docCount + 0.5;
      }
      virtual ~StructQryDocRep() {}
      virtual double termWeight(lemur::api::TERMID_T termID, const lemur::api::DocInfo *info) const { return 0;}
      virtual double termWeight(lemur::api::TERMID_T termID, double dtf, int df) const{
        if (idf)
          return beliefScore(dtf, idf[termID]);
        else
          return beliefScore(dtf, computeIdfScore(df));
      }
      virtual double scoreConstant() const { return 0;}

      void startPassageIteration(int sz) const {
        size = sz;
        increment = size/2;
        start = 0;
        end = size < docEnd ? size : docEnd;
      }
      bool hasMorePassage() const {
        // still some terms in the list.
        return(start < docEnd);
      }

      void nextPassage() const{
        if(start + increment < docEnd)
          start += increment;
        else
          start = docEnd;
        end = (start + size) < docEnd ? (start + size) : docEnd;
      }

      double computeIdfScore(double df) const {
        return log(numer/df)/denom;
      }

      double beliefScore(double df, double idf) const {
        return (defaultBelief + oneMinusDB
                * (df / (df + 0.5 + 1.5* ((end - start)/dla))) * idf);
      }

      lemur::api::DOCID_T did;
      mutable int start; 
      mutable int end;

    private:
      double *idf;
      mutable int size; 
      mutable int increment; 
      int docEnd;  
      double dla;
      double numer, denom;
      double defaultBelief, oneMinusDB;
    };
  }
}

#endif

---