expandweight.h

Go to the documentation of this file.

 
/* Copyright (C) 2007,2008,2009,2011,2016,2023 Olly Betts
 * Copyright (C) 2013 Aarsh Shah
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */
 
#ifndef XAPIAN_INCLUDED_EXPANDWEIGHT_H
#define XAPIAN_INCLUDED_EXPANDWEIGHT_H
 
#include <xapian/database.h>
 
#include "api/termlist.h"
#include "internaltypes.h"
 
#include <string>
#include <vector>
 
namespace Xapian {
namespace Internal {
 
class ExpandStats {
    std::vector<bool> dbs_seen;
 
    Xapian::doclength avlen;
 
    double expand_k;
 
  public:
    Xapian::doccount dbsize;
 
    Xapian::doccount termfreq;
 
    Xapian::termcount rcollection_freq;
 
    Xapian::doccount rtermfreq;
 
    double multiplier;
 
    explicit ExpandStats(Xapian::doclength avlen_)
        : avlen(avlen_), expand_k(0), dbsize(0), termfreq(0),
          rcollection_freq(0), rtermfreq(0), multiplier(0) {
    }
 
    ExpandStats(Xapian::doclength avlen_, double expand_k_)
        : avlen(avlen_), expand_k(expand_k_), dbsize(0), termfreq(0),
          rcollection_freq(0), rtermfreq(0), multiplier(0) {
    }
 
    void accumulate(size_t shard_index,
                    Xapian::termcount wdf, Xapian::termcount doclen,
                    Xapian::doccount subtf, Xapian::doccount subdbsize)
    {
        // Boolean terms may have wdf == 0, but treat that as 1 so such terms
        // get a non-zero weight.
        if (wdf == 0) wdf = 1;
        ++rtermfreq;
        rcollection_freq += wdf;
 
        multiplier += (expand_k + 1) * wdf / (expand_k * doclen / avlen + wdf);
 
        // If we've not seen this sub-database before, then update dbsize and
        // termfreq and note that we have seen it.
        if (shard_index >= dbs_seen.size() || !dbs_seen[shard_index]) {
            if (shard_index >= dbs_seen.size()) {
                dbs_seen.resize(shard_index + 1);
            }
            dbs_seen[shard_index] = true;
            dbsize += subdbsize;
            termfreq += subtf;
        }
    }
 
    /* Clear the statistics collected in the ExpandStats object before using it
     * for a new term. */
    void clear_stats()
    {
        dbs_seen.clear();
        dbsize = 0;
        termfreq = 0;
        rcollection_freq = 0;
        rtermfreq = 0;
        multiplier = 0;
    }
};
 
class ExpandWeight {
    const Xapian::Database db;
 
    Xapian::doccount dbsize;
 
    Xapian::doclength avlen;
 
    Xapian::doccount rsize;
 
    Xapian::termcount collection_freq;
 
    Xapian::totallength collection_len;
 
    bool use_exact_termfreq;
 
    bool want_collection_freq;
 
  public:
    ExpandWeight(const Xapian::Database &db_,
                 Xapian::doccount rsize_,
                 bool use_exact_termfreq_,
                 bool want_collection_freq_)
        : db(db_), dbsize(db.get_doccount()), avlen(db.get_avlength()),
          rsize(rsize_), collection_freq(0),
          collection_len(avlen * dbsize + .5),
          use_exact_termfreq(use_exact_termfreq_),
          want_collection_freq(want_collection_freq_),
          stats(avlen) {}
 
    ExpandWeight(const Xapian::Database &db_,
                 Xapian::doccount rsize_,
                 bool use_exact_termfreq_,
                 bool want_collection_freq_,
                 double expand_k_)
        : db(db_), dbsize(db.get_doccount()), avlen(db.get_avlength()),
          rsize(rsize_), collection_freq(0),
          collection_len(avlen * dbsize + .5),
          use_exact_termfreq(use_exact_termfreq_),
          want_collection_freq(want_collection_freq_),
          stats(avlen, expand_k_) {}
 
    void collect_stats(TermList * merger, const std::string & term);
 
    virtual double get_weight() const = 0;
 
  protected:
    ExpandStats stats;
 
    double get_avlen() const { return avlen; }
 
    Xapian::doccount get_rsize() const { return rsize; }
 
    Xapian::termcount get_collection_freq() const { return collection_freq; }
 
    Xapian::totallength get_collection_len() const { return collection_len; }
 
    Xapian::doccount get_dbsize() const { return dbsize; }
};
 
class TradEWeight : public ExpandWeight {
  public:
    TradEWeight(const Xapian::Database &db_,
                Xapian::doccount rsize_,
                bool use_exact_termfreq_,
                double expand_k_)
        : ExpandWeight(db_, rsize_, use_exact_termfreq_, false, expand_k_) { }
 
    double get_weight() const;
};
 
class Bo1EWeight : public ExpandWeight {
  public:
    Bo1EWeight(const Xapian::Database &db_,
               Xapian::doccount rsize_,
               bool use_exact_termfreq_)
        : ExpandWeight(db_, rsize_, use_exact_termfreq_, true) {}
 
    double get_weight() const;
};
 
}
}
 
#endif // XAPIAN_INCLUDED_EXPANDWEIGHT_H