LCOV - code coverage report
Current view: top level - weight - inl2weight.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 954b5873a738 Lines: 52 65 80.0 %
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 inl2weight.cc
       2                 :            :  * @brief Xapian::InL2Weight class - the InL2 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 : InL2Weight::InL2Weight(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(WDF);
      45                 :         69 :     need_stat(WDF_MAX);
      46                 :         69 :     need_stat(WQF);
      47                 :         69 :     need_stat(TERMFREQ);
      48                 :         69 : }
      49                 :            : 
      50                 :            : InL2Weight *
      51                 :         46 : InL2Weight::clone() const
      52                 :            : {
      53         [ +  - ]:         46 :     return new InL2Weight(param_c);
      54                 :            : }
      55                 :            : 
      56                 :            : void
      57                 :         32 : InL2Weight::init(double factor)
      58                 :            : {
      59         [ +  + ]:         32 :     if (factor == 0.0) {
      60                 :            :         // This object is for the term-independent contribution, and that's
      61                 :            :         // always zero for this scheme.
      62                 :         16 :         return;
      63                 :            :     }
      64                 :            : 
      65                 :         16 :     double wdfn_upper = get_wdf_upper_bound();
      66         [ -  + ]:         16 :     if (wdfn_upper == 0) {
      67                 :          0 :         upper_bound = 0.0;
      68                 :          0 :         return;
      69                 :            :     }
      70                 :            : 
      71                 :         16 :     double termfrequency = get_termfreq();
      72                 :         16 :     double N = get_collection_size();
      73                 :            : 
      74                 :         16 :     wdfn_upper *= log2(1 + (param_c * get_average_length()) /
      75                 :         16 :                     get_doclength_lower_bound());
      76                 :            : 
      77                 :            :     // wdfn * L = wdfn / (wdfn + 1) = 1 / (1 + 1 / wdfn).
      78                 :            :     // To maximize the product, we need to minimize the denominator and so we use wdfn_upper in (1 / wdfn).
      79                 :         16 :     double maximum_wdfn_product_L = wdfn_upper / (wdfn_upper + 1.0);
      80                 :            : 
      81                 :            :     // This term is constant for all documents.
      82                 :         16 :     double idf_max = log2((N + 1) / (termfrequency + 0.5));
      83                 :            : 
      84                 :            :     /* Calculate constant values to be used in get_sumpart() upfront. */
      85                 :         16 :     wqf_product_idf = get_wqf() * idf_max * factor;
      86                 :         16 :     c_product_avlen = param_c * get_average_length();
      87                 :            : 
      88                 :         16 :     upper_bound = wqf_product_idf * maximum_wdfn_product_L * factor;
      89                 :            : }
      90                 :            : 
      91                 :            : string
      92                 :       1564 : InL2Weight::name() const
      93                 :            : {
      94         [ +  - ]:       1564 :     return "Xapian::InL2Weight";
      95                 :            : }
      96                 :            : 
      97                 :            : string
      98                 :       1559 : InL2Weight::short_name() const
      99                 :            : {
     100         [ +  - ]:       1559 :     return "inl2";
     101                 :            : }
     102                 :            : 
     103                 :            : string
     104                 :         14 : InL2Weight::serialise() const
     105                 :            : {
     106                 :         14 :     return serialise_double(param_c);
     107                 :            : }
     108                 :            : 
     109                 :            : InL2Weight *
     110                 :          6 : InL2Weight::unserialise(const string & s) const
     111                 :            : {
     112                 :          6 :     const char *ptr = s.data();
     113                 :          6 :     const char *end = ptr + s.size();
     114         [ +  - ]:          6 :     double c = unserialise_double(&ptr, end);
     115         [ +  + ]:          6 :     if (rare(ptr != end))
     116 [ +  - ][ +  - ]:          1 :         throw Xapian::SerialisationError("Extra data in InL2Weight::unserialise()");
                 [ +  - ]
     117 [ +  - ][ +  - ]:          5 :     return new InL2Weight(c);
     118                 :            : }
     119                 :            : 
     120                 :            : double
     121                 :         14 : InL2Weight::get_sumpart(Xapian::termcount wdf, Xapian::termcount len,
     122                 :            :                         Xapian::termcount) const
     123                 :            : {
     124         [ -  + ]:         14 :     if (wdf == 0) return 0.0;
     125                 :         14 :     double wdfn = wdf;
     126                 :            : 
     127                 :         14 :     wdfn *= log2(1 + c_product_avlen / len);
     128                 :            : 
     129                 :         14 :     double wdfn_product_L = wdfn / (wdfn + 1.0);
     130                 :            : 
     131                 :         14 :     return (wqf_product_idf * wdfn_product_L);
     132                 :            : }
     133                 :            : 
     134                 :            : double
     135                 :         32 : InL2Weight::get_maxpart() const
     136                 :            : {
     137                 :         32 :     return upper_bound;
     138                 :            : }
     139                 :            : 
     140                 :            : double
     141                 :          0 : InL2Weight::get_sumextra(Xapian::termcount, Xapian::termcount) const
     142                 :            : {
     143                 :          0 :     return 0;
     144                 :            : }
     145                 :            : 
     146                 :            : double
     147                 :         16 : InL2Weight::get_maxextra() const
     148                 :            : {
     149                 :         16 :     return 0;
     150                 :            : }
     151                 :            : 
     152                 :            : InL2Weight *
     153                 :          0 : InL2Weight::create_from_parameters(const char * p) const
     154                 :            : {
     155         [ #  # ]:          0 :     if (*p == '\0')
     156         [ #  # ]:          0 :         return new Xapian::InL2Weight();
     157                 :          0 :     double k = 1.0;
     158         [ #  # ]:          0 :     if (!Xapian::Weight::Internal::double_param(&p, &k))
     159 [ #  # ][ #  # ]:          0 :         Xapian::Weight::Internal::parameter_error("Parameter is invalid", "inl2");
     160         [ #  # ]:          0 :     if (*p)
     161 [ #  # ][ #  # ]:          0 :         Xapian::Weight::Internal::parameter_error("Extra data after parameter", "inl2");
     162 [ #  # ][ #  # ]:          0 :     return new Xapian::InL2Weight(k);
     163                 :            : }
     164                 :            : 
     165                 :            : }

Generated by: LCOV version 1.11