weight.h

Go to the documentation of this file.

 
/* Copyright (C) 2004-2024 Olly Betts
 * Copyright (C) 2009 Lemur Consulting Ltd
 * Copyright (C) 2013,2014 Aarsh Shah
 * Copyright (C) 2016,2017 Vivek Pal
 *
 * 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, see
 * <https://www.gnu.org/licenses/>.
 */
 
#ifndef XAPIAN_INCLUDED_WEIGHT_H
#define XAPIAN_INCLUDED_WEIGHT_H
 
#include <string>
 
#include <xapian/database.h>
#include <xapian/deprecated.h>
#include <xapian/registry.h>
#include <xapian/types.h>
#include <xapian/visibility.h>
 
namespace Xapian {
 
class XAPIAN_VISIBILITY_DEFAULT Weight {
  protected:
    typedef enum {
        COLLECTION_SIZE = 0,
        RSET_SIZE = 0,
        AVERAGE_LENGTH = 4,
        TERMFREQ = 1,
        RELTERMFREQ = 1,
        QUERY_LENGTH = 0,
        WQF = 0,
        WDF = 2,
        DOC_LENGTH = 8,
        DOC_LENGTH_MIN = 16,
        DOC_LENGTH_MAX = 32,
        WDF_MAX = 64,
        COLLECTION_FREQ = 1,
        UNIQUE_TERMS = 128,
        TOTAL_LENGTH = 256,
        WDF_DOC_MAX = 512,
        UNIQUE_TERMS_MIN = 1024,
        UNIQUE_TERMS_MAX = 2048,
        DB_DOC_LENGTH_MIN = 4096,
        DB_DOC_LENGTH_MAX = 8192,
        DB_UNIQUE_TERMS_MIN = 16384,
        DB_UNIQUE_TERMS_MAX = 32768,
        DB_WDF_MAX = 65536,
        IS_BOOLWEIGHT_ = static_cast<int>(0x80000000)
    } stat_flags;
 
    void need_stat(stat_flags flag) {
        stats_needed = stat_flags(stats_needed | flag);
    }
 
    virtual void init(double factor) = 0;
 
  private:
    void operator=(const Weight &);
 
    stat_flags stats_needed;
 
    Xapian::doccount collection_size_;
 
    Xapian::doccount rset_size_;
 
    Xapian::doclength average_length_;
 
    Xapian::doccount termfreq_;
 
    // The collection frequency of the term.
    Xapian::termcount collectionfreq_;
 
    Xapian::doccount reltermfreq_;
 
    Xapian::termcount query_length_;
 
    Xapian::termcount wqf_;
 
    Xapian::termcount doclength_lower_bound_;
 
    Xapian::termcount doclength_upper_bound_;
 
    Xapian::termcount wdf_upper_bound_;
 
    Xapian::totallength total_length_;
 
    Xapian::termcount unique_terms_lower_bound_;
 
    Xapian::termcount unique_terms_upper_bound_;
 
    Xapian::termcount db_doclength_lower_bound_;
 
    Xapian::termcount db_doclength_upper_bound_;
 
    Xapian::termcount db_wdf_upper_bound_;
 
    Xapian::termcount db_unique_terms_lower_bound_;
 
    Xapian::termcount db_unique_terms_upper_bound_;
 
  public:
 
    Weight() : stats_needed() { }
 
    class Internal;
 
    virtual ~Weight();
 
    virtual Weight * clone() const = 0;
 
    virtual std::string name() const;
 
    virtual std::string serialise() const;
 
    virtual Weight * unserialise(const std::string & serialised) const;
 
    virtual double get_sumpart(Xapian::termcount wdf,
                               Xapian::termcount doclen,
                               Xapian::termcount uniqterms,
                               Xapian::termcount wdfdocmax) const = 0;
 
    virtual double get_maxpart() const = 0;
 
    virtual double get_sumextra(Xapian::termcount doclen,
                                Xapian::termcount uniqterms,
                                Xapian::termcount wdfdocmax) const;
 
    virtual double get_maxextra() const;
 
    XAPIAN_VISIBILITY_INTERNAL
    void init_(const Internal & stats, Xapian::termcount query_len_,
               const std::string & term, Xapian::termcount wqf_,
               double factor,
               const Xapian::Database::Internal* shard,
               void* postlist);
 
    XAPIAN_VISIBILITY_INTERNAL
    void init_(const Internal & stats, Xapian::termcount query_len_,
               double factor, Xapian::doccount termfreq,
               Xapian::doccount reltermfreq, Xapian::termcount collection_freq,
               const Xapian::Database::Internal* shard);
 
    XAPIAN_VISIBILITY_INTERNAL
    void init_(const Internal & stats, Xapian::termcount query_len_,
               const Xapian::Database::Internal* shard);
 
    bool get_sumpart_needs_doclength_() const {
        return stats_needed & DOC_LENGTH;
    }
 
    bool get_sumpart_needs_wdf_() const {
        return stats_needed & WDF;
    }
 
    bool get_sumpart_needs_uniqueterms_() const {
        return stats_needed & UNIQUE_TERMS;
    }
 
    static const Weight * create(const std::string & scheme,
                                 const Registry & reg = Registry());
 
    virtual Weight * create_from_parameters(const char * params) const;
 
    bool is_bool_weight_() const {
        // We use a special flag bit to make this check efficient.  Note we
        // can't use (get_maxpart() == 0.0) since that's not required to work
        // without init() having been called.
        return stats_needed & IS_BOOLWEIGHT_;
    }
 
    bool get_sumpart_needs_wdfdocmax_() const {
        return stats_needed & WDF_DOC_MAX;
    }
 
  protected:
    XAPIAN_VISIBILITY_INTERNAL
    Weight(const Weight &);
 
    Xapian::doccount get_collection_size() const { return collection_size_; }
 
    Xapian::doccount get_rset_size() const { return rset_size_; }
 
    Xapian::doclength get_average_length() const { return average_length_; }
 
    Xapian::doccount get_termfreq() const { return termfreq_; }
 
    Xapian::doccount get_reltermfreq() const { return reltermfreq_; }
 
    Xapian::termcount get_collection_freq() const { return collectionfreq_; }
 
    Xapian::termcount get_query_length() const { return query_length_; }
 
    Xapian::termcount get_wqf() const { return wqf_; }
 
    Xapian::termcount get_doclength_upper_bound() const {
        return doclength_upper_bound_;
    }
 
    Xapian::termcount get_doclength_lower_bound() const {
        return doclength_lower_bound_;
    }
 
    Xapian::termcount get_wdf_upper_bound() const {
        return wdf_upper_bound_;
    }
 
    Xapian::totallength get_total_length() const {
        return total_length_;
    }
 
    Xapian::termcount get_unique_terms_upper_bound() const {
        return unique_terms_upper_bound_;
    }
 
    Xapian::termcount get_unique_terms_lower_bound() const {
        return unique_terms_lower_bound_;
    }
 
    Xapian::termcount get_db_doclength_upper_bound() const {
        return db_doclength_upper_bound_;
    }
 
    Xapian::termcount get_db_doclength_lower_bound() const {
        return db_doclength_lower_bound_;
    }
 
    Xapian::termcount get_db_unique_terms_upper_bound() const {
        return db_unique_terms_upper_bound_;
    }
 
    Xapian::termcount get_db_unique_terms_lower_bound() const {
        return db_unique_terms_lower_bound_;
    }
 
    Xapian::termcount get_db_wdf_upper_bound() const {
        return db_wdf_upper_bound_;
    }
};
 
class XAPIAN_VISIBILITY_DEFAULT BoolWeight : public Weight {
    BoolWeight * clone() const;
 
    void init(double factor);
 
  public:
    BoolWeight() {
        need_stat(IS_BOOLWEIGHT_);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    BoolWeight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    BoolWeight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT TfIdfWeight : public Weight {
  public:
    enum class wdf_norm : unsigned char {
        NONE = 1,
 
        BOOLEAN = 2,
 
        SQUARE = 3,
 
        LOG = 4,
 
        PIVOTED = 5,
 
        LOG_AVERAGE = 6,
 
        AUG_LOG = 7,
 
        SQRT = 8,
 
        AUG_AVERAGE = 9,
 
        MAX = 10,
 
        AUG = 11
    };
 
    enum class idf_norm : unsigned char {
        NONE = 1,
 
        TFIDF = 2,
 
        SQUARE = 3,
 
        FREQ = 4,
 
        PROB = 5,
 
        PIVOTED = 6,
 
        GLOBAL_FREQ = 7,
 
        LOG_GLOBAL_FREQ = 8,
 
        INCREMENTED_GLOBAL_FREQ = 9,
 
        SQRT_GLOBAL_FREQ = 10
    };
 
    enum class wt_norm : unsigned char {
        NONE = 1
    };
  private:
    wdf_norm wdf_norm_;
    idf_norm idf_norm_;
    wt_norm wt_norm_;
 
    double wqf_factor;
 
    double idfn;
 
    double param_slope, param_delta;
 
    TfIdfWeight * clone() const;
 
    void init(double factor);
 
    /* When additional normalizations are implemented in the future, the additional statistics for them
       should be accessed by these functions. */
    double get_wdfn(Xapian::termcount wdf,
                    Xapian::termcount len,
                    Xapian::termcount uniqterms,
                    Xapian::termcount wdfdocmax,
                    wdf_norm wdf_normalization) const;
    double get_idfn(idf_norm idf_normalization) const;
    double get_wtn(double wt, wt_norm wt_normalization) const;
 
  public:
    explicit TfIdfWeight(const std::string& normalizations)
        : TfIdfWeight(normalizations, 0.2, 1.0) {}
 
    TfIdfWeight(const std::string &normalizations, double slope, double delta);
 
    TfIdfWeight(wdf_norm wdf_normalization,
                idf_norm idf_normalization,
                wt_norm wt_normalization)
        : TfIdfWeight(wdf_normalization, idf_normalization,
                      wt_normalization, 0.2, 1.0) {}
 
    TfIdfWeight(wdf_norm wdf_norm_, idf_norm idf_norm_,
                wt_norm wt_norm_, double slope, double delta);
 
    TfIdfWeight()
        : wdf_norm_(wdf_norm::NONE), idf_norm_(idf_norm::TFIDF),
          wt_norm_(wt_norm::NONE), param_slope(0.2), param_delta(1.0)
    {
        need_stat(WQF);
        need_stat(TERMFREQ);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(COLLECTION_SIZE);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    TfIdfWeight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterm,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    TfIdfWeight * create_from_parameters(const char * params) const;
};
 
 
class XAPIAN_VISIBILITY_DEFAULT BM25Weight : public Weight {
    mutable Xapian::doclength len_factor;
 
    mutable double termweight;
 
    double param_k1, param_k2, param_k3, param_b;
 
    Xapian::doclength param_min_normlen;
 
    BM25Weight * clone() const;
 
    void init(double factor);
 
  public:
    BM25Weight(double k1, double k2, double k3, double b, double min_normlen)
        : param_k1(k1), param_k2(k2), param_k3(k3), param_b(b),
          param_min_normlen(min_normlen)
    {
        if (param_k1 < 0) param_k1 = 0;
        if (param_k2 < 0) param_k2 = 0;
        if (param_k3 < 0) param_k3 = 0;
        if (param_b < 0) {
            param_b = 0;
        } else if (param_b > 1) {
            param_b = 1;
        }
        need_stat(COLLECTION_SIZE);
        need_stat(RSET_SIZE);
        need_stat(TERMFREQ);
        need_stat(RELTERMFREQ);
        need_stat(WDF);
        need_stat(WDF_MAX);
        if (param_k2 != 0 || (param_k1 != 0 && param_b != 0)) {
            need_stat(DOC_LENGTH_MIN);
            need_stat(AVERAGE_LENGTH);
        }
        if (param_k1 != 0 && param_b != 0) need_stat(DOC_LENGTH);
        if (param_k2 != 0) {
            need_stat(DOC_LENGTH);
            need_stat(QUERY_LENGTH);
        }
        if (param_k3 != 0) need_stat(WQF);
    }
 
    BM25Weight()
        : param_k1(1), param_k2(0), param_k3(1), param_b(0.5),
          param_min_normlen(0.5)
    {
        need_stat(COLLECTION_SIZE);
        need_stat(RSET_SIZE);
        need_stat(TERMFREQ);
        need_stat(RELTERMFREQ);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(DOC_LENGTH_MIN);
        need_stat(AVERAGE_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(WQF);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    BM25Weight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterm,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms,
                        Xapian::termcount wdfdocmax) const;
    double get_maxextra() const;
 
    BM25Weight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT BM25PlusWeight : public Weight {
    mutable Xapian::doclength len_factor;
 
    mutable double termweight;
 
    double param_k1, param_k2, param_k3, param_b;
 
    Xapian::doclength param_min_normlen;
 
    double param_delta;
 
    BM25PlusWeight * clone() const;
 
    void init(double factor);
 
  public:
    BM25PlusWeight(double k1, double k2, double k3, double b,
                   double min_normlen, double delta)
        : param_k1(k1), param_k2(k2), param_k3(k3), param_b(b),
          param_min_normlen(min_normlen), param_delta(delta)
    {
        if (param_k1 < 0) param_k1 = 0;
        if (param_k2 < 0) param_k2 = 0;
        if (param_k3 < 0) param_k3 = 0;
        if (param_delta < 0) param_delta = 0;
        if (param_b < 0) {
            param_b = 0;
        } else if (param_b > 1) {
            param_b = 1;
        }
        need_stat(COLLECTION_SIZE);
        need_stat(RSET_SIZE);
        need_stat(TERMFREQ);
        need_stat(RELTERMFREQ);
        need_stat(WDF);
        need_stat(WDF_MAX);
        if (param_k2 != 0 || (param_k1 != 0 && param_b != 0)) {
            need_stat(DOC_LENGTH_MIN);
            need_stat(AVERAGE_LENGTH);
        }
        if (param_k1 != 0 && param_b != 0) need_stat(DOC_LENGTH);
        if (param_k2 != 0) {
            need_stat(DOC_LENGTH);
            need_stat(QUERY_LENGTH);
        }
        if (param_k3 != 0) need_stat(WQF);
    }
 
    BM25PlusWeight()
        : param_k1(1), param_k2(0), param_k3(1), param_b(0.5),
          param_min_normlen(0.5), param_delta(1)
    {
        need_stat(COLLECTION_SIZE);
        need_stat(RSET_SIZE);
        need_stat(TERMFREQ);
        need_stat(RELTERMFREQ);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(DOC_LENGTH_MIN);
        need_stat(AVERAGE_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(WQF);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    BM25PlusWeight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms,
                        Xapian::termcount wdfdocmax) const;
    double get_maxextra() const;
 
    BM25PlusWeight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_DEPRECATED_CLASS TradWeight : public BM25Weight
{
  public:
    explicit TradWeight(double k = 1.0) : BM25Weight(k, 0.0, 0.0, 1.0, 0.0) { }
};
 
class XAPIAN_VISIBILITY_DEFAULT InL2Weight : public Weight {
    double param_c;
 
    double upper_bound;
 
    double wqf_product_idf;
    double c_product_avlen;
 
    InL2Weight * clone() const;
 
    void init(double factor);
 
  public:
    explicit InL2Weight(double c);
 
    InL2Weight()
    : param_c(1.0)
    {
        need_stat(AVERAGE_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
        need_stat(COLLECTION_SIZE);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(WQF);
        need_stat(TERMFREQ);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    InL2Weight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    InL2Weight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT IfB2Weight : public Weight {
    double param_c;
 
    double upper_bound;
 
    double wqf_product_idf;
    double c_product_avlen;
    double B_constant;
 
    IfB2Weight * clone() const;
 
    void init(double factor);
 
  public:
    explicit IfB2Weight(double c);
 
    IfB2Weight() : param_c(1.0) {
        need_stat(AVERAGE_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
        need_stat(COLLECTION_SIZE);
        need_stat(COLLECTION_FREQ);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(WQF);
        need_stat(TERMFREQ);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    IfB2Weight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterm,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    IfB2Weight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT IneB2Weight : public Weight {
    double param_c;
 
    double upper_bound;
 
    double wqf_product_idf;
    double c_product_avlen;
    double B_constant;
 
    IneB2Weight * clone() const;
 
    void init(double factor);
 
  public:
    explicit IneB2Weight(double c);
 
    IneB2Weight() : param_c(1.0) {
        need_stat(AVERAGE_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
        need_stat(COLLECTION_SIZE);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(WQF);
        need_stat(COLLECTION_FREQ);
        need_stat(TERMFREQ);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    IneB2Weight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    IneB2Weight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT BB2Weight : public Weight {
    double param_c;
 
    double upper_bound;
 
    double c_product_avlen;
    double B_constant;
    double wt;
    double stirling_constant_1;
    double stirling_constant_2;
 
    BB2Weight * clone() const;
 
    void init(double factor);
 
  public:
    explicit BB2Weight(double c);
 
    BB2Weight() : param_c(1.0) {
        need_stat(AVERAGE_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
        need_stat(COLLECTION_SIZE);
        need_stat(COLLECTION_FREQ);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(WQF);
        need_stat(TERMFREQ);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    BB2Weight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    BB2Weight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT DLHWeight : public Weight {
    double upper_bound;
 
    double log_constant;
    double wqf_product_factor;
 
    DLHWeight * clone() const;
 
    void init(double factor);
 
  public:
    DLHWeight() {
        need_stat(DOC_LENGTH);
        need_stat(COLLECTION_FREQ);
        need_stat(WDF);
        need_stat(WQF);
        need_stat(WDF_MAX);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
        need_stat(TOTAL_LENGTH);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    DLHWeight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    DLHWeight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT PL2Weight : public Weight {
    double factor;
 
    double param_c;
 
    double upper_bound;
 
    double P1, P2;
 
    double cl;
 
    PL2Weight * clone() const;
 
    void init(double factor_);
 
  public:
    explicit PL2Weight(double c);
 
    PL2Weight() : param_c(1.0) {
        need_stat(AVERAGE_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
        need_stat(COLLECTION_SIZE);
        need_stat(COLLECTION_FREQ);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(WQF);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    PL2Weight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    PL2Weight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT PL2PlusWeight : public Weight {
    double factor;
 
    double param_c;
 
    double param_delta;
 
    double upper_bound;
 
    double P1, P2;
 
    double cl;
 
    double mean;
 
    double dw;
 
    PL2PlusWeight * clone() const;
 
    void init(double factor_);
 
  public:
    PL2PlusWeight(double c, double delta);
 
    PL2PlusWeight()
        : param_c(1.0), param_delta(0.8) {
        need_stat(AVERAGE_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
        need_stat(COLLECTION_SIZE);
        need_stat(COLLECTION_FREQ);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(WQF);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    PL2PlusWeight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    PL2PlusWeight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT DPHWeight : public Weight {
    double upper_bound;
 
    double log_constant;
    double wqf_product_factor;
 
    DPHWeight * clone() const;
 
    void init(double factor);
 
  public:
    DPHWeight() {
        need_stat(DOC_LENGTH);
        need_stat(COLLECTION_FREQ);
        need_stat(WDF);
        need_stat(WQF);
        need_stat(WDF_MAX);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
        need_stat(TOTAL_LENGTH);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    DPHWeight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    DPHWeight * create_from_parameters(const char * params) const;
};
 
 
class XAPIAN_VISIBILITY_DEFAULT LMJMWeight : public Weight {
    double factor;
 
    double param_lambda;
 
    double multiplier;
 
    LMJMWeight* clone() const;
 
    void init(double factor_);
 
  public:
    explicit LMJMWeight(double lambda = 0.0) : param_lambda(lambda) {
        need_stat(WQF);
        need_stat(QUERY_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(COLLECTION_FREQ);
        need_stat(TOTAL_LENGTH);
        need_stat(DOC_LENGTH_MIN);
    }
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterm,
                       Xapian::termcount wdfdocmax) const;
 
    double get_maxpart() const;
 
    std::string name() const;
 
    std::string serialise() const;
    LMJMWeight* unserialise(const std::string& serialised) const;
 
    LMJMWeight* create_from_parameters(const char* params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT LMDirichletWeight : public Weight {
    double factor;
 
    double param_mu;
 
    double param_delta;
 
    double multiplier;
 
    double extra_offset;
 
    LMDirichletWeight* clone() const;
 
    void init(double factor_);
 
  public:
    explicit LMDirichletWeight(double mu = 2000.0, double delta = 0.05)
        : param_mu(mu), param_delta(delta) {
        need_stat(WQF);
        need_stat(QUERY_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(COLLECTION_FREQ);
        need_stat(TOTAL_LENGTH);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
    }
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterm,
                       Xapian::termcount wdfdocmax) const;
 
    double get_maxpart() const;
 
    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount,
                        Xapian::termcount) const;
 
    double get_maxextra() const;
 
    std::string name() const;
 
    std::string serialise() const;
    LMDirichletWeight* unserialise(const std::string& serialised) const;
 
    LMDirichletWeight* create_from_parameters(const char* params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT LMAbsDiscountWeight : public Weight {
    double factor;
 
    double param_delta;
 
    double multiplier;
 
    double extra_offset;
 
    LMAbsDiscountWeight* clone() const;
 
    void init(double factor_);
 
  public:
    explicit LMAbsDiscountWeight(double delta = 0.7) : param_delta(delta) {
        need_stat(WQF);
        need_stat(QUERY_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(COLLECTION_FREQ);
        need_stat(TOTAL_LENGTH);
        need_stat(DOC_LENGTH_MIN);
        need_stat(UNIQUE_TERMS);
        need_stat(DOC_LENGTH_MAX);
    }
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount,
                       Xapian::termcount uniqterm,
                       Xapian::termcount wdfdocmax) const;
 
    double get_maxpart() const;
 
    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount,
                        Xapian::termcount) const;
 
    double get_maxextra() const;
 
    std::string name() const;
 
    std::string serialise() const;
    LMAbsDiscountWeight* unserialise(const std::string& serialised) const;
 
    LMAbsDiscountWeight* create_from_parameters(const char* params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT LM2StageWeight : public Weight {
    double factor;
 
    double param_lambda;
 
    double param_mu;
 
    double multiplier;
 
    double extra_offset;
 
    LM2StageWeight* clone() const;
 
    void init(double factor_);
 
  public:
    explicit LM2StageWeight(double lambda = 0.7, double mu = 2000.0)
        : param_lambda(lambda), param_mu(mu)
    {
        need_stat(WQF);
        need_stat(QUERY_LENGTH);
        need_stat(DOC_LENGTH);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(COLLECTION_FREQ);
        need_stat(TOTAL_LENGTH);
        need_stat(DOC_LENGTH_MIN);
        need_stat(DOC_LENGTH_MAX);
    }
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterm,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterm,
                        Xapian::termcount wdfdocmax) const;
    double get_maxextra() const;
 
    std::string name() const;
 
    std::string serialise() const;
    LM2StageWeight* unserialise(const std::string& serialised) const;
 
    LM2StageWeight* create_from_parameters(const char* params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT CoordWeight : public Weight {
    double factor;
 
  public:
    CoordWeight * clone() const;
 
    void init(double factor_);
 
    CoordWeight() { }
 
    std::string name() const;
 
    std::string serialise() const;
    CoordWeight * unserialise(const std::string & serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterms,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    CoordWeight * create_from_parameters(const char * params) const;
};
 
class XAPIAN_VISIBILITY_DEFAULT DiceWeight : public Weight {
    double numerator;
 
    double upper_bound;
 
    void init(double factor);
 
  public:
    DiceWeight* clone() const;
 
    DiceWeight() {
        need_stat(WQF);
        need_stat(QUERY_LENGTH);
        need_stat(UNIQUE_TERMS);
        need_stat(UNIQUE_TERMS_MIN);
    }
 
    std::string name() const;
 
    std::string serialise() const;
    DiceWeight* unserialise(const std::string& serialised) const;
 
    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterm,
                       Xapian::termcount wdfdocmax) const;
    double get_maxpart() const;
 
    DiceWeight* create_from_parameters(const char* params) const;
};
}
 
#endif // XAPIAN_INCLUDED_WEIGHT_H