LCOV - code coverage report
Current view: top level - weight - ifb2weight.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 954b5873a738 Lines: 54 67 80.6 %
Date: 2019-06-30 05:20:33 Functions: 10 12 83.3 %
Branches: 20 54 37.0 %

           Branch data     Line data    Source code
       1                 :            : /** @file ifb2weight.cc
       2                 :            :  * @brief Xapian::IfB2Weight class - the IfB2 weighting scheme of the DFR framework.
       3                 :            :  */
       4                 :            : /* Copyright (C) 2013,2014 Aarsh Shah
       5                 :            :  *
       6                 :            :  * This program is free software; you can redistribute it and/or
       7                 :            :  * modify it under the terms of the GNU General Public License as
       8                 :            :  * published by the Free Software Foundation; either version 2 of the
       9                 :            :  * License, or (at your option) any later version.
      10                 :            :  *
      11                 :            :  * This program is distributed in the hope that it will be useful
      12                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      14                 :            :  * GNU General Public License for more details.
      15                 :            :  *
      16                 :            :  * You should have received a copy of the GNU General Public License
      17                 :            :  * along with this program; if not, write to the Free Software
      18                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
      19                 :            :  */
      20                 :            : 
      21                 :            : #include <config.h>
      22                 :            : 
      23                 :            : #include "xapian/weight.h"
      24                 :            : #include "common/log2.h"
      25                 :            : #include "weightinternal.h"
      26                 :            : 
      27                 :            : #include "serialise-double.h"
      28                 :            : 
      29                 :            : #include "xapian/error.h"
      30                 :            : 
      31                 :            : using namespace std;
      32                 :            : 
      33                 :            : namespace Xapian {
      34                 :            : 
      35                 :         71 : IfB2Weight::IfB2Weight(double c)
      36                 :         73 :     : param_c(c)
      37                 :            : {
      38         [ +  + ]:         71 :     if (param_c <= 0)
      39 [ +  - ][ +  - ]:          2 :         throw Xapian::InvalidArgumentError("Parameter c is invalid.");
                 [ +  - ]
      40                 :         69 :     need_stat(AVERAGE_LENGTH);
      41                 :         69 :     need_stat(DOC_LENGTH);
      42                 :         69 :     need_stat(DOC_LENGTH_MIN);
      43                 :         69 :     need_stat(COLLECTION_SIZE);
      44                 :         69 :     need_stat(COLLECTION_FREQ);
      45                 :         69 :     need_stat(WDF);
      46                 :         69 :     need_stat(WDF_MAX);
      47                 :         69 :     need_stat(WQF);
      48                 :         69 :     need_stat(TERMFREQ);
      49                 :         69 : }
      50                 :            : 
      51                 :            : IfB2Weight *
      52                 :         46 : IfB2Weight::clone() const
      53                 :            : {
      54         [ +  - ]:         46 :     return new IfB2Weight(param_c);
      55                 :            : }
      56                 :            : 
      57                 :            : void
      58                 :         32 : IfB2Weight::init(double factor)
      59                 :            : {
      60         [ +  + ]:         32 :     if (factor == 0.0) {
      61                 :            :         // This object is for the term-independent contribution, and that's
      62                 :            :         // always zero for this scheme.
      63                 :         16 :         return;
      64                 :            :     }
      65                 :            : 
      66                 :         16 :     double wdfn_upper = get_wdf_upper_bound();
      67         [ -  + ]:         16 :     if (wdfn_upper == 0) {
      68                 :          0 :         upper_bound = 0.0;
      69                 :          0 :         return;
      70                 :            :     }
      71                 :            : 
      72                 :         16 :     double F = get_collection_freq();
      73                 :         16 :     double N = get_collection_size();
      74                 :            : 
      75                 :         16 :     wdfn_upper *= log2(1 + (param_c * get_average_length()) /
      76                 :         16 :                     get_doclength_lower_bound());
      77                 :            : 
      78                 :            :     // This term is constant for all documents.
      79                 :         16 :     double idf_max = log2((N + 1.0) / (F + 0.5));
      80                 :            : 
      81                 :            :     /* Calculate constant values to be used in get_sumpart(). */
      82                 :         16 :     wqf_product_idf = get_wqf() * idf_max * factor;
      83                 :         16 :     c_product_avlen = param_c * get_average_length();
      84                 :         16 :     B_constant = (F + 1.0) / get_termfreq();
      85                 :            : 
      86                 :            :     // wdfn * B = wdfn * (F + 1.0) / (get_termfreq() * (wdfn + 1.0)).
      87                 :            :     // By cancelling out wdfn, we get (F + 1.0) / (get_termfreq() * (1.0 + 1.0 / wdfn)).
      88                 :            :     // In order to maximize the product, we need to minimize the denominator, and so we use wdfn_upper.
      89                 :         16 :     double max_wdfn_product_B = wdfn_upper * B_constant / (wdfn_upper + 1.0);
      90                 :            : 
      91                 :         16 :     upper_bound = wqf_product_idf * max_wdfn_product_B * factor;
      92                 :            : }
      93                 :            : 
      94                 :            : string
      95                 :       1564 : IfB2Weight::name() const
      96                 :            : {
      97         [ +  - ]:       1564 :     return "Xapian::IfB2Weight";
      98                 :            : }
      99                 :            : 
     100                 :            : string
     101                 :       1559 : IfB2Weight::short_name() const
     102                 :            : {
     103         [ +  - ]:       1559 :     return "ifb2";
     104                 :            : }
     105                 :            : 
     106                 :            : string
     107                 :         14 : IfB2Weight::serialise() const
     108                 :            : {
     109                 :         14 :     return serialise_double(param_c);
     110                 :            : }
     111                 :            : 
     112                 :            : IfB2Weight *
     113                 :          6 : IfB2Weight::unserialise(const string & s) const
     114                 :            : {
     115                 :          6 :     const char *ptr = s.data();
     116                 :          6 :     const char *end = ptr + s.size();
     117         [ +  - ]:          6 :     double c = unserialise_double(&ptr, end);
     118         [ +  + ]:          6 :     if (rare(ptr != end))
     119 [ +  - ][ +  - ]:          1 :         throw Xapian::SerialisationError("Extra data in IfB2Weight::unserialise()");
                 [ +  - ]
     120 [ +  - ][ +  - ]:          5 :     return new IfB2Weight(c);
     121                 :            : }
     122                 :            : 
     123                 :            : double
     124                 :         14 : IfB2Weight::get_sumpart(Xapian::termcount wdf, Xapian::termcount len,
     125                 :            :                         Xapian::termcount) const
     126                 :            : {
     127         [ -  + ]:         14 :     if (wdf == 0) return 0.0;
     128                 :         14 :     double wdfn = wdf;
     129                 :         14 :     wdfn *= log2(1 + c_product_avlen / len);
     130                 :            : 
     131                 :         14 :     double wdfn_product_B = wdfn * B_constant / (wdfn + 1.0);
     132                 :            : 
     133                 :         14 :     return (wqf_product_idf * wdfn_product_B);
     134                 :            : }
     135                 :            : 
     136                 :            : double
     137                 :         32 : IfB2Weight::get_maxpart() const
     138                 :            : {
     139                 :         32 :     return upper_bound;
     140                 :            : }
     141                 :            : 
     142                 :            : double
     143                 :          0 : IfB2Weight::get_sumextra(Xapian::termcount, Xapian::termcount) const
     144                 :            : {
     145                 :          0 :     return 0;
     146                 :            : }
     147                 :            : 
     148                 :            : double
     149                 :         16 : IfB2Weight::get_maxextra() const
     150                 :            : {
     151                 :         16 :     return 0;
     152                 :            : }
     153                 :            : 
     154                 :            : IfB2Weight *
     155                 :          0 : IfB2Weight::create_from_parameters(const char * p) const
     156                 :            : {
     157         [ #  # ]:          0 :     if (*p == '\0')
     158         [ #  # ]:          0 :         return new Xapian::IfB2Weight();
     159                 :          0 :     double k = 1.0;
     160         [ #  # ]:          0 :     if (!Xapian::Weight::Internal::double_param(&p, &k))
     161 [ #  # ][ #  # ]:          0 :         Xapian::Weight::Internal::parameter_error("Parameter is invalid", "ifb2");
     162         [ #  # ]:          0 :     if (*p)
     163 [ #  # ][ #  # ]:          0 :         Xapian::Weight::Internal::parameter_error("Extra data after parameter", "ifb2");
     164 [ #  # ][ #  # ]:          0 :     return new Xapian::IfB2Weight(k);
     165                 :            : }
     166                 :            : 
     167                 :            : }

Generated by: LCOV version 1.11