~ubuntu-branches/ubuntu/trusty/swish-e/trusty

/*

 

$Id: rank.c,v 1.25 2006/10/18 02:58:02 karman Exp $

 

 

    This file is part of Swish-e.

 

    Swish-e 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.

 

    Swish-e 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 Swish-e; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    

    See the COPYING file that accompanies the Swish-e distribution for details

    of the GNU GPL and the special exception available for linking against

    the Swish-e library.

 

** Mon May  9 14:51:21 CDT 2005

** added GPL (nothing previously)

    

*/

 

 

 

        SWISH   *sw;

        IndexFILE  *indexf;

        int     scheme;

 

 

        indexf  = r->db_results->indexf;

        sw      = indexf->sw;

        scheme  = sw->RankScheme;

 

        switch ( scheme )

        {

 

           case 0:

           {

                return ( getrankDEF( r ) );

           }

 

           case 1:

           {

                if ( indexf->header.ignoreTotalWordCountWhenRanking ) {

                   fprintf(stderr, "IgnoreTotalWordCountWhenRanking must be 0 to use IDF ranking\n");

                   exit(1);

                }

 

                return ( getrankIDF( r ) );

           }

 

           default:

           {

                return ( getrankDEF( r ) );

           }

 

        }

/* 2001-11 jmruiz With thousands results (>1000000) this routine is a bottleneck.

    unsigned int        *posdata;

    int         words;  /* number of word positions (total words, not unique) in the given file -- probably should be per metaname */

    if ( freq > 100 )

        return ( r->rank = rank / 100);

 

    words = getTotalWordsInFile( indexf, r->filenum );

 

    unsigned int        *posdata;

    int         total_files;

    int         total_words;

    int         average_words;

    int         density;

    int         idf;

    int         total_word_freq;

    int         word_weight;

    int         word_score;

    /* int density_magic        = 2; */

 

 

 

 

 

/* this first part is identical to getrankDEF -- could be optimized as a single function */

 

 

 

 

    word_score  = 1;

    freq        = r->frequency;

 

 

 

    if ( freq > 100 )

 

 

    /*

    IDF is the Inverse Document Frequency, or, the weight of the word in relationship to the

 

 

 

    total_files         = sw->TotalFiles;

    total_word_freq     = r->tfrequency;

    idf                 = (int) ( log( total_files / total_word_freq ) * 1000 );

 

 

        idf = 1;

        /* only ubiquitous words like 'the' get idfs < 1.

        these should probably be stopwords anyway... */

 

 

                 total_files, total_word_freq, idf );

 

    words = getTotalWordsInFile( indexf, r->filenum );

 

    total_words         = sw->TotalWordPos;

    average_words       = total_words / total_files;

 

         total_words, average_words, words );

 

Amati & Van Rijsbergen "normalization 2" from

        term_freq_density = term_freq * log( 1 + c * av_doc_leng/doc_leng)

 

    density             = freq * log( 1 + ( density_magic * ( average_words / words ) ) ); */

 

 

 

 

/* if for some reason there are 0 words in this document, we'll get a divide by zero

error in this next calculation. why might a doc have no words in it, and yet be in the 

set of matches we're evaluating? maybe because stopwords aren't counted? 

it's a mystery, just like mankind...

set words=1 if <1 so that we at least avoid the core dump -- would it be better to somehow

skip it altogether? throw an error? let's warn on stderr for now, just to alert the user

that something is awry. */

 

    if ( words < 1 ) {

    

        fprintf(stderr, "Word count for document %d is zero\n", r->filenum );

        words = 1;

        

    }

 

 

    density             = ( ( average_words * 100 ) / words ) * freq;

 

        density = 1;

 

 

    word_weight         = ( density * idf ) / 100;

 

 

 

 

 

        fprintf(stderr, "Rank after IDF weighting: %d  \n", word_score );

        /* scaling word_score?? */

 

        /* Scale the rank - this was originally based on frequency */

        /* Uses lookup tables for values <= 1000, otherwise calculate */

 

        word_score = scale_word_score( word_score );

 

        return ( r->rank = word_score / 100 );

 

        return  score > 1000

                ? (int) floor( (log((double)score) * 10000 ) + 0.5)

                : swish_log[score];