LCOV - code coverage report
Current view: top level - weight - ineb2weight.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core fcfb185a9dd5 Lines: 56 69 81.2 %
Date: 2019-04-18 16:33:14 Functions: 10 12 83.3 %
Branches: 20 54 37.0 %

           Branch data     Line data    Source code
       1                 :            : /** @file ineb2weight.cc
       2                 :            :  * @brief Xapian::IneB2Weight class - the IneB2 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                 :        144 : IneB2Weight::IneB2Weight(double c) : param_c(c) {
      36         [ +  + ]:         71 :     if (param_c <= 0)
      37 [ +  - ][ +  - ]:          2 :         throw Xapian::InvalidArgumentError("Parameter c is invalid.");
                 [ +  - ]
      38                 :         69 :     need_stat(AVERAGE_LENGTH);
      39                 :         69 :     need_stat(DOC_LENGTH);
      40                 :         69 :     need_stat(DOC_LENGTH_MIN);
      41                 :         69 :     need_stat(COLLECTION_SIZE);
      42                 :         69 :     need_stat(WDF);
      43                 :         69 :     need_stat(WDF_MAX);
      44                 :         69 :     need_stat(WQF);
      45                 :         69 :     need_stat(COLLECTION_FREQ);
      46                 :         69 :     need_stat(TERMFREQ);
      47                 :         69 : }
      48                 :            : 
      49                 :            : IneB2Weight *
      50                 :         46 : IneB2Weight::clone() const
      51                 :            : {
      52         [ +  - ]:         46 :     return new IneB2Weight(param_c);
      53                 :            : }
      54                 :            : 
      55                 :            : void
      56                 :         32 : IneB2Weight::init(double factor)
      57                 :            : {
      58         [ +  + ]:         32 :     if (factor == 0.0) {
      59                 :            :         // This object is for the term-independent contribution, and that's
      60                 :            :         // always zero for this scheme.
      61                 :         16 :         return;
      62                 :            :     }
      63                 :            : 
      64                 :         16 :     double wdfn_upper = get_wdf_upper_bound();
      65         [ -  + ]:         16 :     if (wdfn_upper == 0) {
      66                 :          0 :         upper_bound = 0.0;
      67                 :          0 :         return;
      68                 :            :     }
      69                 :            : 
      70                 :         16 :     wdfn_upper *= log2(1 + (param_c * get_average_length()) /
      71                 :         16 :                     get_doclength_lower_bound());
      72                 :            : 
      73                 :         16 :     double N = get_collection_size();
      74                 :         16 :     double F = get_collection_freq();
      75                 :         16 :     double termfreq = get_termfreq();
      76                 :            : 
      77                 :         16 :     double max_wdfn_product_B = (F + 1.0) / (termfreq + (termfreq / wdfn_upper));
      78                 :            : 
      79                 :         16 :     double mean = F / N;
      80                 :            : 
      81                 :         16 :     double expected_max = N * (1.0 - exp(-mean));
      82                 :            : 
      83                 :         16 :     double idf_max = log2((N + 1.0) / (expected_max + 0.5));
      84                 :            : 
      85                 :            :     /* Calculate constant values used in get_sumpart(). */
      86                 :         16 :     wqf_product_idf = get_wqf() * idf_max * factor;
      87                 :         16 :     c_product_avlen = param_c * get_average_length();
      88                 :         16 :     B_constant = (F + 1.0) / termfreq;
      89                 :            : 
      90                 :         16 :     upper_bound = max_wdfn_product_B * idf_max * get_wqf() * factor;
      91                 :            : }
      92                 :            : 
      93                 :            : string
      94                 :       1444 : IneB2Weight::name() const
      95                 :            : {
      96         [ +  - ]:       1444 :     return "Xapian::IneB2Weight";
      97                 :            : }
      98                 :            : 
      99                 :            : string
     100                 :       1439 : IneB2Weight::short_name() const
     101                 :            : {
     102         [ +  - ]:       1439 :     return "ineb2";
     103                 :            : }
     104                 :            : 
     105                 :            : string
     106                 :         14 : IneB2Weight::serialise() const
     107                 :            : {
     108                 :         14 :     return serialise_double(param_c);
     109                 :            : }
     110                 :            : 
     111                 :            : IneB2Weight *
     112                 :          6 : IneB2Weight::unserialise(const string & s) const
     113                 :            : {
     114                 :          6 :     const char *ptr = s.data();
     115                 :          6 :     const char *end = ptr + s.size();
     116         [ +  - ]:          6 :     double c = unserialise_double(&ptr, end);
     117         [ +  + ]:          6 :     if (rare(ptr != end))
     118 [ +  - ][ +  - ]:          1 :         throw Xapian::SerialisationError("Extra data in IneB2Weight::unserialise()");
                 [ +  - ]
     119 [ +  - ][ +  - ]:          5 :     return new IneB2Weight(c);
     120                 :            : }
     121                 :            : 
     122                 :            : double
     123                 :         70 : IneB2Weight::get_sumpart(Xapian::termcount wdf, Xapian::termcount len,
     124                 :            :                          Xapian::termcount) const
     125                 :            : {
     126         [ -  + ]:         70 :     if (wdf == 0) return 0.0;
     127                 :         70 :     double wdfn = wdf;
     128                 :            : 
     129                 :         70 :     wdfn *= log2(1 + c_product_avlen / len);
     130                 :            : 
     131                 :         70 :     double wdfn_product_B = wdfn * B_constant / (wdfn + 1.0);
     132                 :            : 
     133                 :         70 :     return (wdfn_product_B * wqf_product_idf);
     134                 :            : }
     135                 :            : 
     136                 :            : double
     137                 :         32 : IneB2Weight::get_maxpart() const
     138                 :            : {
     139                 :         32 :     return upper_bound;
     140                 :            : }
     141                 :            : 
     142                 :            : double
     143                 :          0 : IneB2Weight::get_sumextra(Xapian::termcount, Xapian::termcount) const
     144                 :            : {
     145                 :          0 :     return 0;
     146                 :            : }
     147                 :            : 
     148                 :            : double
     149                 :         16 : IneB2Weight::get_maxextra() const
     150                 :            : {
     151                 :         16 :     return 0;
     152                 :            : }
     153                 :            : 
     154                 :            : IneB2Weight *
     155                 :          0 : IneB2Weight::create_from_parameters(const char * p) const
     156                 :            : {
     157         [ #  # ]:          0 :     if (*p == '\0')
     158         [ #  # ]:          0 :         return new Xapian::IneB2Weight();
     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", "ineb2");
     162         [ #  # ]:          0 :     if (*p)
     163 [ #  # ][ #  # ]:          0 :         Xapian::Weight::Internal::parameter_error("Extra data after parameter", "ineb2");
     164 [ #  # ][ #  # ]:          0 :     return new Xapian::IneB2Weight(k);
     165                 :            : }
     166                 :            : 
     167                 :            : }

Generated by: LCOV version 1.11