weight.h

Go to the documentation of this file.

/* Copyright (C) 2004,2007,2008,2009,2010,2011,2012,2015,2016,2019 Olly Betts
 * Copyright (C) 2009 Lemur Consulting Ltd
 * Copyright (C) 2013,2014 Aarsh Shah
 * Copyright (C) 2016 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */

#ifndef XAPIAN_INCLUDED_WEIGHT_H
#define XAPIAN_INCLUDED_WEIGHT_H

#include <string>

#include <xapian/types.h>
#include <xapian/visibility.h>

namespace Xapian {

class XAPIAN_VISIBILITY_DEFAULT Weight {
  protected:
    typedef enum {
        COLLECTION_SIZE = 1,
        RSET_SIZE = 2,
        AVERAGE_LENGTH = 4,
        TERMFREQ = 8,
        RELTERMFREQ = 16,
        QUERY_LENGTH = 32,
        WQF = 64,
        WDF = 128,
        DOC_LENGTH = 256,
        DOC_LENGTH_MIN = 512,
        DOC_LENGTH_MAX = 1024,
        WDF_MAX = 2048,
        COLLECTION_FREQ = 4096,
        UNIQUE_TERMS = 8192,
        TOTAL_LENGTH = COLLECTION_SIZE | AVERAGE_LENGTH
    } 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_;

  public:

    Weight() : stats_needed() { }

    typedef enum {
        TWO_STAGE_SMOOTHING = 1,
        DIRICHLET_SMOOTHING = 2,
        ABSOLUTE_DISCOUNT_SMOOTHING = 3,
        JELINEK_MERCER_SMOOTHING = 4,
        DIRICHLET_PLUS_SMOOTHING = 5
    } type_smoothing;

    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) const = 0;

    virtual double get_maxpart() const = 0;

    virtual double get_sumextra(Xapian::termcount doclen,
                                Xapian::termcount uniqterms) const = 0;

    virtual double get_maxextra() const = 0;

    void init_(const Internal & stats, Xapian::termcount query_len_,
               const std::string & term, Xapian::termcount wqf_,
               double factor);

    void init_(const Internal & stats, Xapian::termcount query_len_,
               const std::string & term, Xapian::termcount wqf_,
               double factor, void* postlist);

    void init_(const Internal & stats, Xapian::termcount query_len_,
               double factor, Xapian::doccount termfreq,
               Xapian::doccount reltermfreq, Xapian::termcount collection_freq);

    void init_(const Internal & stats, Xapian::termcount query_len_);

    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;
    }

    bool is_bool_weight_() const {
        // Checking the name isn't ideal, but (get_maxpart() == 0.0) isn't
        // required to work without init() having been called.  We can at
        // least avoid the virtual method call in most non-BoolWeight cases
        // as most other classes will need at least some stats.
        return stats_needed == 0 && name() == "Xapian::BoolWeight";
    }

  protected:
    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 Xapian::totallength(average_length_ * collection_size_ + 0.5);
    }
};

class XAPIAN_VISIBILITY_DEFAULT BoolWeight : public Weight {
    BoolWeight * clone() const;

    void init(double factor);

  public:
    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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() const;
};

class XAPIAN_VISIBILITY_DEFAULT TfIdfWeight : public Weight {
    /* Three character string indicating the normalizations for tf(wdf), idf and
       tfidf weight. */
    std::string normalizations;

    double factor;

    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, char c) const;
    double get_idfn(Xapian::doccount termfreq, char c) const;
    double get_wtn(double wt, char c) const;

  public:
    explicit TfIdfWeight(const std::string &normalizations);

    TfIdfWeight()
    : normalizations("ntn")
    {
        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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() 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(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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() 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(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 uniqterm) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() const;
};

class XAPIAN_VISIBILITY_DEFAULT TradWeight : public Weight {
    mutable Xapian::doclength len_factor;

    mutable double termweight;

    double param_k;

    TradWeight * clone() const;

    void init(double factor);

  public:
    explicit TradWeight(double k = 1.0) : param_k(k) {
        if (param_k < 0) param_k = 0;
        if (param_k != 0.0) {
            need_stat(AVERAGE_LENGTH);
            need_stat(DOC_LENGTH);
        }
        need_stat(COLLECTION_SIZE);
        need_stat(RSET_SIZE);
        need_stat(TERMFREQ);
        need_stat(RELTERMFREQ);
        need_stat(DOC_LENGTH_MIN);
        need_stat(WDF);
        need_stat(WDF_MAX);
    }

    std::string name() const;

    std::string serialise() const;
    TradWeight * unserialise(const std::string & serialised) const;

    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqueterms) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() const;
};

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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() 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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() 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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() 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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() const;
};

class XAPIAN_VISIBILITY_DEFAULT DLHWeight : public Weight {
    double lower_bound;

    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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() const;
};

class XAPIAN_VISIBILITY_DEFAULT PL2Weight : public Weight {
    double param_c;

    double lower_bound;

    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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() 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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() const;
};

class XAPIAN_VISIBILITY_DEFAULT DPHWeight : public Weight {
    double upper_bound;

    double lower_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) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen,
                        Xapian::termcount uniqterms) const;
    double get_maxextra() const;
};


class XAPIAN_VISIBILITY_DEFAULT LMWeight : public Weight {
    type_smoothing select_smoothing;

    // Parameters for handling negative value of log, and for smoothing.
    double param_log, param_smoothing1, param_smoothing2;

    double weight_collection;

    LMWeight * clone() const;

    void init(double factor);

  public:
    // Unigram LM Constructor to specifically mention all parameters for handling negative log value and smoothing.
    explicit LMWeight(double param_log_ = 0.0,
                      type_smoothing select_smoothing_ = TWO_STAGE_SMOOTHING,
                      double param_smoothing1_ = -1.0,
                      double param_smoothing2_ = -1.0)
        : select_smoothing(select_smoothing_), param_log(param_log_), param_smoothing1(param_smoothing1_),
          param_smoothing2(param_smoothing2_)
    {
        if (param_smoothing1 < 0) param_smoothing1 = 0.7;
        if (param_smoothing2 < 0) {
            if (select_smoothing == TWO_STAGE_SMOOTHING)
                param_smoothing2 = 2000.0;
            else
                param_smoothing2 = 0.05;
        }
        need_stat(DOC_LENGTH);
        need_stat(RSET_SIZE);
        need_stat(TERMFREQ);
        need_stat(RELTERMFREQ);
        need_stat(DOC_LENGTH_MAX);
        need_stat(WDF);
        need_stat(WDF_MAX);
        need_stat(COLLECTION_FREQ);
        need_stat(TOTAL_LENGTH);
        if (select_smoothing == ABSOLUTE_DISCOUNT_SMOOTHING)
            need_stat(UNIQUE_TERMS);
        if (select_smoothing == DIRICHLET_PLUS_SMOOTHING)
            need_stat(DOC_LENGTH_MIN);
    }

    std::string name() const;

    std::string serialise() const;
    LMWeight * unserialise(const std::string & serialised) const;

    double get_sumpart(Xapian::termcount wdf,
                       Xapian::termcount doclen,
                       Xapian::termcount uniqterm) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount doclen, Xapian::termcount) const;
    double get_maxextra() 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 uniqterm) const;
    double get_maxpart() const;

    double get_sumextra(Xapian::termcount, Xapian::termcount) const;
    double get_maxextra() const;
};

}

#endif // XAPIAN_INCLUDED_WEIGHT_H