index/zvrank.c

   1 /* $Id: zvrank.c,v 1.12 2004-10-28 10:37:15 heikki Exp $
   2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
   3    Index Data Aps
   4
   5    This file is part of the Zebra server.
   6
   7    Zebra is free software; you can redistribute it and/or modify it under
   8    the terms of the GNU General Public License as published by the Free
   9    Software Foundation; either version 2, or (at your option) any later
  10    version.
  11
  12    Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15    for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with Zebra; see the file LICENSE.zebra.  If not, write to the
  19    Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.
  21 */
  22
  23 /*
  24 Zvrank: an experimental ranking algorithm. See doc/zvrank.txt and
  25 source in index/zvrank.c. Enable this by using rank: zvrank in zebra.cfg.
  26 Contributed by Johannes Leveling <Johannes.Leveling at
  27 fernuni-hagen.de>
  28 */
  29
  30 /* Zebra Vector Space Model RANKing
  31 **
  32 ** six (seven) letter identifier for weighting scheme
  33 ** best document weighting:
  34 **  tfc nfc (tpc npc) [original naming]
  35 **  ntc atc  npc apc  [SMART naming, used here]
  36 ** best query weighting:
  37 **  nfx tfx bfx (npx tpx bpx) [original naming]
  38 **  atn ntn btn  apn npn bpn  [SMART naming]
  39 ** -> should set zvrank.weighting-scheme to one of
  40 ** "ntc-atn", "atc-atn", etc.
  41 */
  42
  43
  44 #include <math.h>  /* for log */
  45
  46 #include <stdio.h>
  47 #include <assert.h>
  48 #ifdef WIN32
  49 #include <io.h>
  50 #else
  51 #include <unistd.h>
  52 #endif
  53
  54 #include "index.h"
  55
  56 static double blog(double x) {
  57     /* log_2, log_e or log_10 is used, best to change it here if necessary */
  58     if (x <= 0)
  59         return 0.0;
  60     return log(x); /* / log(base) */
  61 }
  62
  63 /* structures */
  64
  65 struct rank_class_info {
  66     char rscheme[8];    /* name of weighting scheme */
  67 };
  68
  69
  70 struct rs_info {      /* for result set */
  71     int db_docs;        /* number of documents in database (collection) */
  72     int db_terms;       /* number of distinct terms in database (debugging?) */
  73     int db_f_max;       /* maximum of f_t in database (debugging?) */
  74     char *db_f_max_str; /* string (most frequent term) - for debugging */
  75     /**/
  76     char rscheme[8];    /* name of weighting scheme */
  77     /**/
  78     int veclen;
  79     NMEM nmem;
  80     void (*d_tf_fct)(void *, void *);   /* doc term frequency function */
  81     void (*d_idf_fct)(void *, void *);  /* doc idf function */
  82     void (*d_norm_fct)(void *, void *); /* doc normalization function */
  83     /**/
  84     void (*q_tf_fct)(void *, void *);   /* query term frequency function */
  85     void (*q_idf_fct)(void *, void *);  /* query idf function */
  86     void (*q_norm_fct)(void *, void *); /* query normalization function */
  87
  88     double (*sim_fct)(void *, void *);  /* similarity function (scoring function) */
  89     struct ds_info *qdoc;
  90     struct ds_info *rdoc;
  91 };
  92 typedef struct rs_info *RS;
  93
  94 static void prn_rs(RS rs) { /* for debugging */
  95     yaz_log(LOG_DEBUG, "* RS:");
  96     yaz_log(LOG_DEBUG, " db_docs:   %d", rs->db_docs);
  97     yaz_log(LOG_DEBUG, " db_terms:  %d", rs->db_terms);
  98     yaz_log(LOG_DEBUG, " f_max:     %d", rs->db_f_max);
  99     yaz_log(LOG_DEBUG, " f_max_str: %s", rs->db_f_max_str);
 100     yaz_log(LOG_DEBUG, " veclen:    %d", rs->veclen);
 101     /* rscheme implies functions */
 102     yaz_log(LOG_DEBUG, " rscheme:   %s", rs->rscheme);
 103     return;
 104 }
 105
 106 struct ds_info {       /* document info */
 107     char *docid;         /* unique doc identifier */
 108     int  docno;          /* doc number */
 109     int doclen;          /* document length */
 110     int d_f_max;         /* maximum number of any term in doc (needed) */
 111     char *d_f_max_str;   /* most frequent term in d - for debugging */
 112     int veclen;          /* vector length */
 113     struct ts_info *terms;
 114     double docsim;       /* similarity in [0, ..., 1] (= score/1000) */
 115 };
 116 typedef struct ds_info* DS;
 117
 118 #if 0
 119 static void prn_ds(DS ds) { /* for debugging */
 120     yaz_log(LOG_DEBUG, " * DS:");
 121     yaz_log(LOG_DEBUG, " docid:      %s", ds->docid);
 122     yaz_log(LOG_DEBUG, " docno:      %d", ds->docno);
 123     yaz_log(LOG_DEBUG, " doclen:     %d", ds->doclen);
 124     yaz_log(LOG_DEBUG, " d_f_max:    %d", ds->d_f_max);
 125     yaz_log(LOG_DEBUG, " d_f_max_str:%s", ds->d_f_max_str);
 126     yaz_log(LOG_DEBUG, " veclen:     %d", ds->veclen);
 127     return;
 128 }
 129 #endif
 130
 131 struct ts_info {       /* term info */
 132     char *name;
 133     int *id;
 134     /**/
 135     zint gocc;
 136     int locc;
 137     double tf;
 138     double idf;
 139     double wt;
 140 };
 141 typedef struct ts_info *TS;
 142
 143 #if 0
 144 static void prn_ts(TS ts) { /* for debugging */
 145     yaz_log(LOG_DEBUG, " * TERM:%s gocc:%d locc:%d  tf:%f idf:%f wt:%f",
 146             ts->name, ts->gocc, ts->locc, ts->tf, ts->idf, ts->wt);
 147     return;
 148 }
 149 #endif
 150
 151 /* end structures */
 152
 153 /* *** */
 154
 155 /*
 156 ** weighting functions
 157 ** check: RS is not needed anymore
 158 */
 159
 160 /* calculate and store new term frequency vector */
 161 static void tf_none(void *rsi, void *dsi) {
 162     DS ds=(DS)dsi;
 163     int i, veclen, freq;
 164     /* no conversion. 1 <= tf */
 165     veclen=ds->veclen;
 166     for (i=0; i < veclen; i++) {
 167         freq=ds->terms[i].locc;
 168         ds->terms[i].tf=freq;
 169     }
 170     return;
 171 }
 172
 173 static void tf_binary(void *rsi, void *dsi) {
 174     DS ds=(DS)dsi;
 175     int i, veclen, freq;
 176     /* tf in {0, 1} */
 177     veclen=ds->veclen;
 178     for (i=0; i < veclen; i++) {
 179         freq=ds->terms[i].locc;
 180         if (freq > 0)
 181             ds->terms[i].tf=1.0;
 182         else
 183             ds->terms[i].tf=0.0;
 184     }
 185     return;
 186 }
 187
 188 static void tf_max_norm(void *rsi, void *dsi) {
 189     DS ds=(DS)dsi;
 190     double tf_max;
 191     int i, veclen, freq;
 192     /* divide each term by max, so 0 <= tf <= 1 */
 193     tf_max=ds->d_f_max; /* largest frequency of t in document */
 194     veclen=ds->veclen;
 195     for (i=0; i < veclen; i++) {
 196         freq=ds->terms[i].locc;
 197         if ((freq > 0) &&
 198             (tf_max > 0.0))
 199             ds->terms[i].tf=freq/tf_max;
 200         else
 201             ds->terms[i].tf=0.0;
 202     }
 203     return;
 204 }
 205
 206 static void tf_aug_norm(void *rsi, void *dsi) {
 207     DS ds=(DS)dsi;
 208     double K;
 209     double tf_max;
 210     int i, veclen, freq;
 211     /* augmented normalized tf. 0.5 <= tf <= 1  for K = 0.5 */
 212     tf_max=ds->d_f_max; /* largest frequency of t in document */
 213     veclen=ds->veclen;
 214     K=0.5; /* zvrank.const-K */
 215     for (i=0; i < veclen; i++) {
 216         freq=ds->terms[i].locc;
 217         if ((freq > 0) &&
 218             (tf_max > 0.0))
 219             ds->terms[i].tf=K+(1.0-K)*(freq/tf_max);
 220         else
 221             ds->terms[i].tf=0.0;
 222     }
 223     return;
 224 }
 225
 226 static void tf_square(void *rsi, void *dsi) {
 227     DS ds=(DS)dsi;
 228     int i, veclen, freq;
 229     /* tf ^ 2 */
 230     veclen=ds->veclen;
 231     for (i=0; i < veclen; i++) {
 232         freq=ds->terms[i].locc;
 233         if (freq > 0)
 234             ds->terms[i].tf=freq*freq;
 235         else
 236             ds->terms[i].tf=0.0;
 237     }
 238     return;
 239 }
 240
 241 static void tf_log(void *rsi, void *dsi) {
 242     DS ds=(DS)dsi;
 243     int i, veclen, freq;
 244     /* logarithmic tf */
 245     veclen=ds->veclen;
 246     for (i=0; i < veclen; i++) {
 247         freq=ds->terms[i].locc;
 248         if (freq > 0)
 249             ds->terms[i].tf=1.0+blog(freq);
 250         else
 251             ds->terms[i].tf=0.0;
 252     }
 253     return;
 254 }
 255
 256 /* calculate and store inverse document frequency vector */
 257 static void idf_none(void *rsi, void *dsi) {
 258     DS ds=(DS)dsi;
 259     int i, veclen;
 260     /* no conversion */
 261     veclen=ds->veclen;
 262     for (i=0; i < veclen; i++) {
 263         ds->terms[i].idf=1.0;
 264     }
 265     return;
 266 }
 267
 268 static void idf_tfidf(void *rsi, void *dsi) {
 269     RS rs=(RS)rsi;
 270     DS ds=(DS)dsi;
 271     zint num_docs, gocc;
 272     int i, veclen;
 273     double idf;
 274     /* normal tfidf weight */
 275     veclen=ds->veclen;
 276     num_docs=rs->db_docs;
 277     for (i=0; i < veclen; i++) {
 278         gocc=ds->terms[i].gocc;
 279         if (gocc==0)
 280             idf=0.0;
 281         else
 282             idf=blog((double) (num_docs/gocc));
 283         ds->terms[i].idf=idf;
 284     }
 285     return;
 286 }
 287
 288 static void idf_prob(void *rsi, void *dsi) {
 289     RS rs=(RS)rsi;
 290     DS ds=(DS)dsi;
 291     zint num_docs, gocc;
 292     int i, veclen;
 293     double idf;
 294     /* probabilistic formulation */
 295     veclen=ds->veclen;
 296     num_docs=rs->db_docs;
 297     for (i=0; i < veclen; i++) {
 298         gocc=ds->terms[i].gocc;
 299         if (gocc==0)
 300             idf=0.0;
 301         else
 302             idf=blog((double) ((num_docs-gocc)/gocc));
 303         ds->terms[i].idf=idf;
 304     }
 305     return;
 306 }
 307
 308 static void idf_freq(void *rsi, void *dsi) {
 309     RS rs=(RS)rsi;
 310     DS ds=(DS)dsi;
 311     int num_docs;
 312     int i, veclen;
 313     double idf;
 314     /* frequency formulation */
 315     veclen=ds->veclen;
 316     num_docs=rs->db_docs;
 317     if (num_docs==0)
 318         idf=0.0;
 319     else
 320         idf=1.0/num_docs;
 321     for (i=0; i < veclen; i++) {
 322         ds->terms[i].idf=idf;
 323     }
 324     return;
 325 }
 326
 327 static void idf_squared(void *rsi, void *dsi) {
 328     RS rs=(RS)rsi;
 329     DS ds=(DS)dsi;
 330     zint num_docs, gocc;
 331     int i, veclen;
 332     double idf;
 333     /* idf ^ 2 */
 334     veclen=ds->veclen;
 335     num_docs=rs->db_docs;
 336     yaz_log(LOG_DEBUG, "idf_squared: db_docs required");
 337     for (i=0; i < veclen; i++) {
 338         gocc=ds->terms[i].gocc;
 339         if (gocc==0)
 340             idf=0.0;
 341         else
 342             idf=blog(num_docs/gocc);
 343         idf=idf*idf;
 344         ds->terms[i].idf=idf;
 345     }
 346     return;
 347 }
 348
 349 /* calculate and store normalized weight (tf-idf) vector */
 350 static void norm_none(void *rsi, void *dsi) {
 351     DS ds=(DS)dsi;
 352     int i, veclen;
 353     /* no normalization */
 354     veclen=ds->veclen;
 355     for (i=0; i < veclen; i++) {
 356         ds->terms[i].wt=ds->terms[i].tf*ds->terms[i].idf;
 357     }
 358     return;
 359 }
 360
 361 static void norm_sum(void *rsi, void *dsi) {
 362     DS ds=(DS)dsi;
 363     int i, veclen;
 364     double tfs=0.0;
 365     /**/
 366     veclen=ds->veclen;
 367     for (i=0; i < veclen; i++) {
 368         ds->terms[i].wt=ds->terms[i].tf*ds->terms[i].idf;
 369         tfs+=ds->terms[i].wt;
 370     }
 371     if (tfs > 0.0)
 372         for (i=0; i < veclen; i++) {
 373             ds->terms[i].wt=ds->terms[i].wt/tfs;
 374         }
 375     /* else: tfs==0 && ds->terms[i].wt==0 */
 376     return;
 377 }
 378
 379 static void norm_cosine(void *rsi, void *dsi) {
 380     DS ds=(DS)dsi;
 381     int i, veclen;
 382     double tfs=0.0;
 383     /**/
 384     veclen=ds->veclen;
 385     for (i=0; i < veclen; i++) {
 386         ds->terms[i].wt=ds->terms[i].tf*ds->terms[i].idf;
 387         tfs+=(ds->terms[i].wt*ds->terms[i].wt);
 388     }
 389     tfs=sqrt(tfs);
 390     if (tfs > 0.0)
 391         for (i=0; i < veclen; i++) {
 392             ds->terms[i].wt=ds->terms[i].wt/tfs;
 393         }
 394     /* else: tfs==0 && ds->terms[i].wt==0 */
 395     return;
 396 }
 397
 398 static void norm_fourth(void *rsi, void *dsi) {
 399     DS ds=(DS)dsi;
 400     int i, veclen;
 401     double tfs=0.0, fr;
 402     /**/
 403     veclen=ds->veclen;
 404     for (i=0; i < veclen; i++) {
 405         ds->terms[i].wt=ds->terms[i].tf*ds->terms[i].idf;
 406         fr=(ds->terms[i].wt*ds->terms[i].wt);
 407         fr=fr*fr; /* ^ 4 */
 408         tfs+=fr;
 409     }
 410     if (tfs > 0.0)
 411         for (i=0; i < veclen; i++) {
 412             ds->terms[i].wt=ds->terms[i].wt/tfs;
 413         }
 414     /* else: tfs==0 && ds->terms[i].wt==0 */
 415     return;
 416 }
 417
 418 static void norm_max(void *rsi, void *dsi) {
 419     DS ds=(DS)dsi;
 420     int i, veclen;
 421     double tfm=0.0;
 422     /**/
 423     veclen=ds->veclen;
 424     for (i=0; i < veclen; i++) {
 425         ds->terms[i].wt=ds->terms[i].tf*ds->terms[i].idf;
 426         if (ds->terms[i].wt > tfm)
 427             tfm=ds->terms[i].wt;
 428     }
 429     if (tfm > 0.0)
 430         for (i=0; i < veclen; i++) {
 431             ds->terms[i].wt=ds->terms[i].wt/tfm;
 432         }
 433     /* else: tfs==0 && ds->terms[i].wt==0 */
 434     return;
 435 }
 436
 437 /* add: norm_pivot, ... */
 438
 439 static double sim_cosine(void *dsi1, void *dsi2) {
 440     DS ds1=(DS)dsi1;
 441     DS ds2=(DS)dsi2;
 442     int i, veclen;
 443     double smul=0.0, sdiv=0.0, sqr11=0.0, sqr22=0.0;
 444     double v1, v2;
 445     /**/
 446     veclen=ds1->veclen; /* and ds2->veclen */
 447     for (i=0; i < veclen; i++) {
 448         v1=ds1->terms[i].wt;
 449         v2=ds2->terms[i].wt;
 450         smul +=(v1*v2);
 451         sqr11+=(v1*v1);
 452         sqr22+=(v2*v2);
 453     }
 454     sdiv=sqrt(sqr11*sqr22);
 455     if (sdiv==0.0)
 456         return 0.0;
 457     return (smul/sdiv);
 458 }
 459
 460 /* add: norm_jaccard, norm_dice, ... */
 461
 462 /* end weighting functions */
 463
 464 /* *** */
 465
 466 static void zv_init_scheme(RS rs, const char *sname) {
 467     int slen;
 468     char c0, c1, c2, c3, c4, c5, c6;
 469     const char *def_rscheme="ntc-atn"; /* a good default */
 470     /**/
 471     yaz_log(LOG_DEBUG, "zv_init_scheme");
 472     slen=strlen(sname);
 473     if (slen < 7)
 474         yaz_log(LOG_LOG, "zvrank: invalid weighting-scheme \"%s\"", sname);
 475     if (slen > 0) c0=sname[0]; else c0=def_rscheme[0];
 476     if (slen > 1) c1=sname[1]; else c1=def_rscheme[1];
 477     if (slen > 2) c2=sname[2]; else c2=def_rscheme[2];
 478     c3='-';
 479     if (slen > 4) c4=sname[4]; else c4=def_rscheme[4];
 480     if (slen > 5) c5=sname[5]; else c5=def_rscheme[5];
 481     if (slen > 6) c6=sname[6]; else c6=def_rscheme[6];
 482     /**/
 483                       /* assign doc functions */
 484                       switch (c0) {
 485                       case 'b':
 486                           rs->d_tf_fct=tf_binary;
 487                           rs->rscheme[0]='b';
 488                           break;
 489                       case 'm':
 490                           rs->d_tf_fct=tf_max_norm;
 491                           rs->rscheme[0]='m';
 492                           yaz_log(LOG_DEBUG, "tf_max_norm: d_f_max required");
 493                           break;
 494                       case 'a':
 495                           rs->d_tf_fct=tf_aug_norm;
 496                           rs->rscheme[0]='a';
 497                           yaz_log(LOG_DEBUG, "tf_aug_norm: d_f_max required");
 498                           break;
 499                       case 's':
 500                           rs->d_tf_fct=tf_square;
 501                           rs->rscheme[0]='s';
 502                           break;
 503                       case 'l':
 504                           rs->d_tf_fct=tf_log;
 505                           rs->rscheme[0]='l';
 506                           break;
 507                       default: /* 'n' */
 508                           rs->d_tf_fct=tf_none;
 509                           rs->rscheme[0]='n';
 510                       }
 511                       switch (c1) {
 512                       case 't':
 513                           rs->d_idf_fct=idf_tfidf;
 514                           rs->rscheme[1]='t';
 515                           yaz_log(LOG_DEBUG, "idf_tfidf: db_docs required");
 516                           break;
 517                       case 'p':
 518                           rs->d_idf_fct=idf_prob;
 519                           rs->rscheme[1]='p';
 520                           yaz_log(LOG_DEBUG, "idf_prob: db_docs required");
 521                           break;
 522                       case 'f':
 523                           rs->d_idf_fct=idf_freq;
 524                           rs->rscheme[1]='f';
 525                           yaz_log(LOG_DEBUG, "idf_freq: db_docs required");
 526                           break;
 527                       case 's':
 528                           rs->d_idf_fct=idf_squared;
 529                           rs->rscheme[1]='s';
 530                           yaz_log(LOG_DEBUG, "idf_squared: db_docs required");
 531                           break;
 532                       default: /* 'n' */
 533                           rs->d_idf_fct=idf_none;
 534                           rs->rscheme[1]='n';
 535                       }
 536                       switch (c2) {
 537                       case 's':
 538                           rs->d_norm_fct=norm_sum;
 539                           rs->rscheme[2]='s';
 540                           break;
 541                       case 'c':
 542                           rs->d_norm_fct=norm_cosine;
 543                           rs->rscheme[2]='c';
 544                           break;
 545                       case 'f':
 546                           rs->d_norm_fct=norm_fourth;
 547                           rs->rscheme[2]='t';
 548                           break;
 549                       case 'm':
 550                           rs->d_norm_fct=norm_max;
 551                           rs->rscheme[2]='m';
 552                           break;
 553                       default: /* 'n' */
 554                           rs->d_norm_fct=norm_none;
 555                           rs->rscheme[2]='n';
 556                       }
 557                       /**/
 558                       rs->rscheme[3]='-';
 559                       /* assign query functions */
 560                       switch (c4) {
 561                       case 'b':
 562                           rs->q_tf_fct=tf_binary;
 563                           rs->rscheme[4]='b';
 564                           break;
 565                       case 'm':
 566                           rs->q_tf_fct=tf_max_norm;
 567                           yaz_log(LOG_DEBUG, "tf_max_norm: d_f_max required");
 568                           rs->rscheme[4]='m';
 569                           break;
 570                       case 'a':
 571                           rs->q_tf_fct=tf_aug_norm;
 572                           rs->rscheme[4]='a';
 573                           yaz_log(LOG_DEBUG, "tf_aug_norm: d_f_max required");
 574                           break;
 575                       case 's':
 576                           rs->q_tf_fct=tf_square;
 577                           rs->rscheme[4]='s';
 578                           break;
 579                       case 'l':
 580                           rs->q_tf_fct=tf_log;
 581                           rs->rscheme[4]='l';
 582                           break;
 583                       default: /* 'n' */
 584                           rs->q_tf_fct=tf_none;
 585                           rs->rscheme[4]='n';
 586                       }
 587                       switch (c5) {
 588                       case 't':
 589                           rs->q_idf_fct=idf_tfidf;
 590                           rs->rscheme[5]='t';
 591                           yaz_log(LOG_DEBUG, "idf_tfidf: db_docs required");
 592                           break;
 593                       case 'p':
 594                           rs->q_idf_fct=idf_prob;
 595                           rs->rscheme[5]='p';
 596                           yaz_log(LOG_DEBUG, "idf_prob: db_docs required");
 597                           break;
 598                       case 'f':
 599                           rs->q_idf_fct=idf_freq;
 600                           rs->rscheme[5]='f';
 601                           yaz_log(LOG_DEBUG, "idf_freq: db_docs required");
 602                           break;
 603                       case 's':
 604                           rs->q_idf_fct=idf_squared;
 605                           rs->rscheme[5]='s';
 606                           yaz_log(LOG_DEBUG, "idf_squared: db_docs required");
 607                           break;
 608                       default: /* 'n' */
 609                           rs->q_idf_fct=idf_none;
 610                           rs->rscheme[5]='n';
 611                       }
 612                       switch (c6) {
 613                       case 's':
 614                           rs->q_norm_fct=norm_sum;
 615                           rs->rscheme[6]='s';
 616                           break;
 617                       case 'c':
 618                           rs->q_norm_fct=norm_cosine;
 619                           rs->rscheme[6]='c';
 620                           break;
 621                       case 'f':
 622                           rs->q_norm_fct=norm_fourth;
 623                           rs->rscheme[6]='f';
 624                           break;
 625                       case 'm':
 626                           rs->q_norm_fct=norm_max;
 627                           rs->rscheme[6]='m';
 628                           break;
 629                       default: /* 'n' */
 630                           rs->q_norm_fct=norm_none;
 631                           rs->rscheme[6]='n';
 632                       }
 633                       rs->rscheme[7]='\0';
 634                       /**/
 635                       rs->sim_fct=sim_cosine;
 636                       yaz_log(LOG_DEBUG, "zv_scheme %s", rs->rscheme);
 637                       return;
 638 }
 639
 640 static void zv_init(RS rs, const char *rscheme) {
 641     yaz_log(LOG_DEBUG, "zv_init");
 642     /**/
 643     rs->db_docs=100000;   /* assign correct value here */
 644     rs->db_terms=500000;  /* assign correct value here (for debugging) */
 645     rs->db_f_max=50;      /* assign correct value here */
 646     rs->db_f_max_str="a"; /* assign correct value here (for debugging) */
 647     /* FIXME - get those values from somewhere */
 648     zv_init_scheme(rs, rscheme);
 649     return;
 650 }
 651
 652 /******/
 653
 654 /*
 655  * zv_create: Creates/Initialises this rank handler. This routine is
 656  *  called exactly once. The routine returns the class_handle.
 657  */
 658 static void *zv_create (ZebraHandle zh) {
 659     int i;
 660     Res res = zh->res;
 661     const char *wscheme;
 662     struct rank_class_info *ci = (struct rank_class_info *)
 663         xmalloc (sizeof(*ci));
 664     yaz_log(LOG_DEBUG, "zv_create");
 665     wscheme=res_get_def(res, "zvrank.weighting-scheme", "");
 666     for (i=0; wscheme[i] && i < 8; i++)
 667         ci->rscheme[i]=wscheme[i];
 668     ci->rscheme[i] = '\0';
 669     return ci;
 670 }
 671
 672 /*
 673  * zv_destroy: Destroys this rank handler. This routine is called
 674  *  when the handler is no longer needed - i.e. when the server
 675  *  dies. The class_handle was previously returned by create.
 676  */
 677 static void zv_destroy (struct zebra_register *reg, void *class_handle) {
 678     struct rank_class_info *ci = (struct rank_class_info *) class_handle;
 679     yaz_log(LOG_DEBUG, "zv_destroy");
 680     xfree (ci);
 681 }
 682
 683
 684 /*
 685  * zv_begin: Prepares beginning of "real" ranking. Called once for
 686  *  each result set. The returned handle is a "set handle" and
 687  *  will be used in each of the handlers below.
 688  */
 689 static void *zv_begin(struct zebra_register *reg, void *class_handle,
 690                       RSET rset, NMEM nmem, TERMID *terms, int numterms)
 691 {
 692     struct rs_info *rs=(struct rs_info *)nmem_malloc(nmem,sizeof(*rs));
 693     struct rank_class_info *ci=(struct rank_class_info *)class_handle;
 694     int i;
 695     int veclen;
 696     int *ip;
 697     zint gocc;
 698     /**/
 699     yaz_log(LOG_DEBUG, "zv_begin");
 700     veclen= numterms;
 701     zv_init(rs, ci->rscheme);
 702     rs->nmem=nmem;
 703     rs->veclen=veclen;
 704     prn_rs(rs);
 705
 706     rs->qdoc=(struct ds_info *)nmem_malloc(nmem,sizeof(*rs->qdoc));
 707     rs->qdoc->terms=(struct ts_info *)nmem_malloc(nmem,
 708                                 sizeof(*rs->qdoc->terms)*rs->veclen);
 709     rs->qdoc->veclen=veclen;
 710     rs->qdoc->d_f_max=1; /* no duplicates */
 711     rs->qdoc->d_f_max_str="";
 712
 713     rs->rdoc=(struct ds_info *)nmem_malloc(nmem,sizeof(*rs->rdoc));
 714     rs->rdoc->terms=(struct ts_info *)nmem_malloc(nmem,
 715                          sizeof(*rs->rdoc->terms)*rs->veclen);
 716     rs->rdoc->veclen=veclen;
 717     rs->rdoc->d_f_max=10; /* just a guess */
 718     rs->rdoc->d_f_max_str="";
 719     /* yaz_log(LOG_DEBUG, "zv_begin_init"); */
 720     for (i = 0; i < rs->veclen; i++)
 721     {
 722         gocc= rset_count(terms[i]->rset);
 723         terms[i]->rankpriv=ip=nmem_malloc(nmem, sizeof(int));
 724         *ip=i; /* save the index for add() */
 725         /* yaz_log(LOG_DEBUG, "zv_begin_init i=%d gocc=%d", i, gocc); */
 726         rs->qdoc->terms[i].gocc=gocc;
 727         rs->qdoc->terms[i].locc=1;  /* assume query has no duplicate terms */
 728         rs->rdoc->terms[i].gocc=gocc;
 729         rs->rdoc->terms[i].locc=0;
 730     }
 731     (*rs->q_tf_fct)(rs, rs->qdoc); /* we do this once only */
 732     (*rs->q_idf_fct)(rs, rs->qdoc);
 733     (*rs->q_norm_fct)(rs, rs->qdoc);
 734     return rs;
 735 }
 736
 737 /*
 738  * zv_end: Terminates ranking process. Called after a result set
 739  *  has been ranked.
 740  */
 741 static void zv_end (struct zebra_register *reg, void *rsi)
 742 {
 743     yaz_log(LOG_DEBUG, "zv_end");
 744     /* they all are nmem'd */
 745     return;
 746 }
 747
 748 /*
 749  * zv_add: Called for each word occurence in a result set. This routine
 750  *  should be as fast as possible. This routine should "incrementally"
 751  *  update the score.
 752  */
 753 static void zv_add (void *rsi, int seqno, TERMID term) {
 754     RS rs=(RS)rsi;
 755     int *ip = term->rankpriv;
 756     int i=*ip;
 757     rs->rdoc->terms[i].locc++;
 758     yaz_log(LOG_DEBUG, "zvrank zv_add seqno=%d '%s' term_index=%d cnt=%d",
 759              seqno, term->name, i, rs->rdoc->terms[i].locc );
 760 }
 761
 762 /*
 763  * zv_calc: Called for each document in a result. This handler should
 764  *  produce a score based on previous call(s) to the add handler. The
 765  *  score should be between 0 and 1000. If score cannot be obtained
 766  *  -1 should be returned.
 767  */
 768 static int zv_calc (void *rsi, zint sysno)
 769 {
 770     int i, veclen;
 771     int score=0;
 772     double dscore=0.0;
 773     RS rs=(RS)rsi;
 774     /* yaz_log(LOG_DEBUG, "zv_calc"); */
 775     /**/
 776     veclen=rs->veclen;
 777     if (veclen==0)
 778         return -1;
 779     for (i = 0; i < veclen; i++) {
 780         /* qdoc weight has already been calculated */
 781         (*rs->d_tf_fct)(rs, rs->rdoc);
 782         (*rs->d_idf_fct)(rs, rs->rdoc);
 783         (*rs->d_norm_fct)(rs, rs->rdoc);
 784         dscore=rs->sim_fct(rs->qdoc, rs->rdoc);
 785     }
 786     score = (int) (dscore * 1000 +.5);
 787     yaz_log (LOG_DEBUG, "zv_calc: sysno=" ZINT_FORMAT " score=%d",
 788             sysno, score);
 789     if (score > 1000) /* should not happen */
 790         score = 1000;
 791     return (int) score;
 792 }
 793
 794 /*
 795  * Pseudo-meta code with sequence of calls as they occur in a
 796  * server. Handlers are prefixed by --:
 797  *
 798  *     server init
 799  *     -- create
 800  *     foreach search
 801  *        rank result set
 802  *        -- begin
 803  *        foreach record
 804  *           foreach word
 805  *              -- add
 806  *           -- calc
 807  *        -- end
 808  *     -- destroy
 809  *     server close
 810  */
 811
 812 static struct rank_control rank_control_vsm = {
 813     "zvrank",
 814     zv_create,
 815     zv_destroy,
 816     zv_begin,
 817     zv_end,
 818     zv_calc,
 819     zv_add,
 820 };
 821
 822 struct rank_control *rankzv_class = &rank_control_vsm;
 823
 824 /* EOF */