home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1988 / 05 / c_abc / sfs.c next >
Encoding:
C/C++ Source or Header  |  1988-02-22  |  4.4 KB  |  119 lines
  1. /*--------------------------------------------------------*/
  2. /*                      SFS.C                             */
  3. /*               SIMILAR FIELD SEARCH                     */
  4. /*   Ähnlichkeitsvergleich von strings in Datenfeldern    */
  5. /*                                                        */
  6. /*  AUFRUF:  ret = sfs(s,d,mode)                          */
  7. /*               int ret,mode                             */
  8. /*              char s[],d[]                              */
  9. /*                                                        */
  10. /*           ret gibt Korrelation von 0 bis 100 an        */
  11. /*               SFS_ERR, wenn Strings zu lang            */
  12. /*--------------------------------------------------------*/
  13.  
  14. #define I_CASE 1        /* Groß- Klein ignorieren,
  15.                            bei nicht 1 beachten           */
  16. #define SFS_ERR  9999   /* Fehler - String zu lang        */
  17. #define MAX 100         /* maximale Länge                 */
  18.  
  19. #define islower(c) ((c)>='a' && (c)<='z')
  20.                                       /* Kleinbuchstabe ? */
  21. #define toupper(c) (islower(c) ? (c)-32 : (c))
  22.                                             /* mache groß */
  23. #define max(a,b)   ( (a) > (b) ? (a) : (b) )   /* Maximum */
  24.  
  25.  
  26. /* ------------------------ */
  27. /*       _sfs()             */
  28. /* ------------------------ */
  29. /*
  30. Modulinterne Funktion. Wird
  31. von sfs() benutzt.
  32. */
  33. static int _sfs(s,d,mode)
  34. register char *s;          /* Suchfolge                   */
  35. register char *d;          /* Vergleichsfolge             */
  36. int mode;             /* Groß- Kleinschreibung beachten ? */
  37.  
  38. {
  39.   register int zeile =  0; /* Suchfolge                   */
  40.   register int spalte = 0; /* Vergleichsfolge             */
  41.   int last_1 = 0;      /* Merken der letzten Spalte mit 1 */
  42.   int maxsp,maxz;          /* Index der Strings           */
  43.   register int j;          /* allg. Schleifenvariable     */
  44.   int sum = 0;             /* Gesamtsumme der 1en         */
  45.   int sp_sum[MAX];      /* bei Übereinstimmung der Spalte */
  46.  
  47.   maxsp = strlen(d) - 1;
  48.   maxz  = strlen(s) - 1;
  49.   if (maxsp > MAX ) return(SFS_ERR);  /*  zu lang         */
  50.  
  51.   for(j = 0;j <= maxsp;j++) sp_sum[j] = 0;
  52.                            /* Spaltensummen auf 0 setzen  */
  53.   do
  54.     {
  55.       switch(sp_sum[spalte]) /* Spalte bereits  1         */
  56.         {
  57.           case 0:                            /* Nein      */
  58.             if(s[zeile] == d[spalte] ||    /* vergleichen */
  59.                ( mode & I_CASE  &&
  60.                  toupper(s[zeile]) == toupper(d[spalte]) ))
  61.               {
  62.                 sp_sum[spalte] = 1;     /* sind gleich    */
  63.                 if(++spalte > maxsp)
  64.                   zeile = maxz;         /* ENDE forcieren */
  65.                 last_1 = spalte;        /* ++spalte merken*/
  66.                 zeile++;                /* nächste Zeile  */
  67.               }
  68.             else                      /* Zeichen ungleich */
  69.               {
  70.                 if((spalte + 1) > maxsp)/* rechter Rand ? */
  71.                   {
  72.                     spalte = last_1 ;   /* rechts unter
  73.                                            letzter 1      */
  74.                     zeile++;
  75.                   }
  76.                 else
  77.                   spalte++;            /* nur nach rechts */
  78.               }
  79.             break;
  80.  
  81.           case 1:                            /* Ja        */
  82.             if(++spalte > maxsp)          /* rechter Rand */
  83.               {
  84.                 spalte = last_1; /* rechts unter letzte 1 */
  85.                 zeile++;                /*   Zeile runter */
  86.               }
  87.             break;
  88.  
  89.         } /* end switch */
  90.  
  91.     } while(zeile <= maxz);
  92.  
  93.   for(j = 0;j <= maxsp;j++) sum += sp_sum[j];
  94.                                       /* Summe der Einsen */
  95.   return( 200 * sum / (maxz + maxsp + 2) );
  96.          /* entspricht: 100 * ( (sum/((zeile + spalte)/2) ),
  97.             bloß etwas rechnergerechter umgeformt.
  98.             Das + 2 ergibt sich dadurch, daß der Index
  99.             bei Null anfängt.                             */
  100. }
  101.  
  102. /* ------------------------ */
  103. /*        sfs()             */
  104. /* ------------------------ */
  105. /*
  106. Benutzt _sfs() zweimal und
  107. gibt den größeren Wert zurück.
  108. */
  109. int sfs(s,d,mode)
  110. char *s,*d;
  111. int mode;
  112. {
  113. int sd,ds;
  114.   sd = _sfs(s,d,mode);     /* s mit d                     */
  115.   ds = _sfs(d,s,mode);     /* d mit s                     */
  116.   return(max(sd,ds));     /* gib den größeren Wert zurück */
  117. }
  118.  
  119.