include/xapian/weight.h

Go to the documentation of this file.

/* Copyright (C) 2007,2008,2009 Olly Betts
 *
 * 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
    } 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 &);

    virtual Weight * clone() const = 0;

    stat_flags stats_needed;

    Xapian::doccount collection_size_;

    Xapian::doccount rset_size_;

    Xapian::doclength average_length_;

    Xapian::doccount termfreq_;

    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:
    class Internal;

    virtual ~Weight();

    virtual std::string name() const = 0;

    virtual std::string serialise() const = 0;

    virtual Weight * unserialise(const std::string & s) const = 0;

    virtual Xapian::weight get_sumpart(Xapian::termcount wdf,
                                       Xapian::termcount doclen) const = 0;

    virtual Xapian::weight get_maxpart() const = 0;

    virtual Xapian::weight get_sumextra(Xapian::termcount doclen) const = 0;

    virtual Xapian::weight get_maxextra() const = 0;

    Weight * clone_() const { return clone(); }

    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_);

    bool get_sumpart_needs_doclength_() const {
        return stats_needed & DOC_LENGTH;
    }

  protected:
    Weight(const Weight &);

    Weight() : stats_needed() { }

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

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 & s) const;

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

    Xapian::weight get_sumextra(Xapian::termcount doclen) const;
    Xapian::weight get_maxextra() const;
};

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

    mutable Xapian::weight 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_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_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 & s) const;

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

    Xapian::weight get_sumextra(Xapian::termcount doclen) const;
    Xapian::weight get_maxextra() const;
};

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

    mutable Xapian::weight 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_MAX);
    }

    std::string name() const;

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

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

    Xapian::weight get_sumextra(Xapian::termcount doclen) const;
    Xapian::weight get_maxextra() const;
};

}

#endif // XAPIAN_INCLUDED_WEIGHT_H

---