double strcmp95(char *ying, char *yang, long y_length, int *ind_c[])
{
/* Arguments:
ying and yang are pointers to the 2 strings to be compared. The strings
need not be NUL-terminated strings because the length is passed.
y_length is the length of the strings.
ind_c is an array that is used to define whether certain options should be
activated. A nonzero value indicates the option is deactivated.
The options are:
ind_c[0] Increase the probability of a match when the number of matched
characters is large. This option allows for a little more
tolerance when the strings are large. It is not an appropriate
test when comparing fixed length fields such as phone and
social security numbers.
ind_c[1] All lower case characters are converted to upper case prior
to the comparison. Disabling this feature means that the lower
case string "code" will not be recognized as the same as the
upper case string "CODE". Also, the adjustment for similar
characters section only applies to uppercase characters.
The suggested values are all zeros for character strings such as names. */
static int pass=0, adjwt[91][91];
static char sp[39][2] =
{'A','E', 'A','I', 'A','O', 'A','U', 'B','V', 'E','I', 'E','O', 'E','U',
'I','O', 'I','U', 'O','U', 'I','Y', 'E','Y', 'C','G', 'E','F',
'W','U', 'W','V', 'X','K', 'S','Z', 'X','S', 'Q','C', 'U','V',
'M','N', 'L','I', 'Q','O', 'P','R', 'I','J', '2','Z', '5','S',
'8','B', '1','I', '1','L', '0','O', '0','Q', 'C','K', 'G','J',
'E',' ', 'Y',' ', 'S',' '};
char ying_hold[MAX_VAR_SIZE],
yang_hold[MAX_VAR_SIZE],
ying_flag[MAX_VAR_SIZE],
yang_flag[MAX_VAR_SIZE];
double weight, Num_sim;
long minv, search_range, lowlim, ying_length,
hilim, N_trans, Num_com, yang_length;
int yl1, yi_st, N_simi;
register int i, j, k;
/* Initialize the adjwt array on the first call to the function only.
The adjwt array is used to give partial credit for characters that
may be errors due to known phonetic or character recognition errors.
A typical example is to match the letter "O" with the number "0" */
if (!pass) {
pass++;
for (i=0; i<91; i++) for (j=0; j<91; j++) adjwt[i][j] = 0;
for (i=0; i<36; i++) {
char i0 = sp[i][0];
char i1 = sp[i][1];
// printf("indices sp[%d][0]=%c, sp[%d][1]=%c\n", i, i0, i, i1);
// printf(" adjwt[%d][%d]=3, adjwt[%d][%d]=3\n", i0, i1, i1, i0);
adjwt[sp[i][0]][sp[i][1]] = 3;
adjwt[sp[i][1]][sp[i][0]] = 3;
} }
/* If either string is blank - return - added in Version 2 */
if (!strncmp(ying,NULL60,y_length)) return(0.0);
if (!strncmp(yang,NULL60,y_length)) return(0.0);
/* Identify the strings to be compared by stripping off all leading and
trailing spaces. */
k = y_length - 1;
for(j = 0;((ying[j]==' ') && (j < k));j++);
for(i = k;((ying[i]==' ') && (i > 0));i--);
ying_length = i + 1 - j;
yi_st = j;
printf("\n");
printf("ying start: %d\n", yi_st);
printf("ying length: %ld\n", ying_length);
for(j = 0;((yang[j]==' ') && (j < k));j++);
for(i = k;((yang[i]==' ') && (i > 0));i--);
yang_length = i + 1 - j;
printf("yang start: %d\n", j);
printf("yang length: %ld\n", yang_length);
ying_hold[0]=yang_hold[0]=0;
strncat(ying_hold,&ying[yi_st],ying_length);
strncat(yang_hold,&yang[j],yang_length);
if (ying_length > yang_length) {
search_range = ying_length;
minv = yang_length;
}
else {
search_range = yang_length;
minv = ying_length;
}
/* If either string is blank - return */
/* if (!minv) return(0.0); removed in version 2 */
/* Blank out the flags */
ying_flag[0] = yang_flag[0] = 0;
strncat(ying_flag,NULL60,search_range);
strncat(yang_flag,NULL60,search_range);
search_range = (search_range/2) - 1;
if (search_range < 0) search_range = 0; /* added in version 2 */
/* Convert all lower case characters to upper case. */
if (!ind_c[1]) {
for (i = 0;i < ying_length;i++) if (islower(ying_hold[i])) ying_hold[i] -= 32;
for (j = 0;j < yang_length;j++) if (islower(yang_hold[j])) yang_hold[j] -= 32;
}
printf("Search range: %ld\n", search_range);
printf("Minv: %ld\n", minv);
printf("ying hold: '%s'\n", ying_hold);
printf("yang hold: '%s'\n", yang_hold);
printf("\n");
/* Looking only within the search range, count and flag the matched pairs. */
Num_com = 0;
yl1 = yang_length - 1;
for (i = 0;i < ying_length;i++) {
lowlim = (i >= search_range) ? i - search_range : 0;
hilim = ((i + search_range) <= yl1) ? (i + search_range) : yl1;
printf("%d. Looking for char %c in range [%ld, %ld (incl)]\n", i, ying_hold[i],lowlim, hilim);
for (j = lowlim;j <= hilim;j++) {
printf(" j:%2d char: %c\n", j, yang_hold[j]);
if ((yang_flag[j] != '1') && (yang_hold[j] == ying_hold[i])) {
yang_flag[j] = '1';
ying_flag[i] = '1';
Num_com++;
break;
} } }
printf("Num com: %ld\n", Num_com);
printf("ying flag: '%s'\n", ying_flag);
printf("yang flag: '%s'\n", yang_flag);
/* If no characters in common - return */
if (!Num_com) return(0.0);
/* Count the number of transpositions */
k = N_trans = 0;
for (i = 0;i < ying_length;i++) {
if (ying_flag[i] == '1') {
for (j = k;j < yang_length;j++) {
if (yang_flag[j] == '1') {
k = j + 1;
break;
} }
if (ying_hold[i] != yang_hold[j]) N_trans++;
} }
printf("Transpositions: %ld\n", N_trans);
N_trans = N_trans / 2;
weight= Num_com / ((double) ying_length) + Num_com / ((double) yang_length)
+ ((double) (Num_com - N_trans)) / ((double) Num_com);
weight = weight / 3.0;
printf("First weight: %.6f\n", weight);
/* adjust for similarities in nonmatched characters */
N_simi = 0;
if (minv > Num_com) {
for (i = 0;i < ying_length;i++) {
if (ying_flag[i] == ' ' && INRANGE(ying_hold[i])) {
for (j = 0;j < yang_length;j++) {
if (yang_flag[j] == ' ' && INRANGE(yang_hold[j])) {
if (adjwt[ying_hold[i]][yang_hold[j]] > 0) {
N_simi += adjwt[ying_hold[i]][yang_hold[j]];
yang_flag[j] = '2';
break;
} } } } } }
Num_sim = ((double) N_simi)/10.0 + Num_com;
printf("N_simi : %d\n", N_simi);
printf("Num sim: %.6f\n", Num_sim);
printf("ying flag: '%s'\n", ying_flag);
printf("yang flag: '%s'\n", yang_flag);
/* Main weight computation. */
weight= Num_sim / ((double) ying_length) + Num_sim / ((double) yang_length)
+ ((double) (Num_com - N_trans)) / ((double) Num_com);
weight = weight / 3.0;
printf("Weight: %.6f\n", weight);
/* Continue to boost the weight if the strings are similar */
if (weight > 0.7) {
/* Adjust for having up to the first 4 characters in common */
j = (minv >= 4) ? 4 : minv;
for (i=0;((i<j)&&(ying_hold[i]==yang_hold[i])&&(NOTNUM(ying_hold[i])));i++)
printf("pre-match: %d\n", i);
if (i) {
printf("final pre-match: %d\n", i);
weight += i * 0.1 * (1.0 - weight);
}
printf("Adjusted weight: %.6f\n", weight);
/* Optionally adjust for long strings. */
/* After agreeing beginning chars, at least two more must agree and
the agreeing characters must be > .5 of remaining characters. */
if ((!ind_c[0]) && (minv>4) && (Num_com>i+1) && (2*Num_com>=minv+i))
if (NOTNUM(ying_hold[0])) {
weight += (double) (1.0-weight) *
((double) (Num_com-i-1) / ((double) (ying_length+yang_length-i*2+2)));
printf("Re-adjusted weight: %.6f\n", weight);
}
}
return(weight);
} /* strcmp95 */
/* borrowed heavily from strcmp95.c
* http://www.census.gov/geo/msb/stand/strcmp.c
*/
double _jaro_winkler(const char *ying, const char *yang,
bool long_tolerance, bool winklerize)
{
/* Arguments:
ying
yang
pointers to the 2 strings to be compared.
long_tolerance
Increase the probability of a match when the number of matched
characters is large. This option allows for a little more
tolerance when the strings are large. It is not an appropriate
test when comparing fixed length fields such as phone and
social security numbers.
*/
char *ying_flag=0, *yang_flag=0;
double weight;
long ying_length, yang_length, min_len;
long search_range;
long lowlim, hilim;
long trans_count, common_chars;
int i, j, k;
// ensure that neither string is blank
ying_length = strlen(ying);
yang_length = strlen(yang);
if (!ying_length || !yang_length) return 0;
search_range = min_len = (ying_length > yang_length) ? ying_length : yang_length;
// Blank out the flags
ying_flag = alloca(ying_length + 1);
if (!ying_flag) return NaN;
yang_flag = alloca(yang_length + 1);
if (!yang_flag) return NaN;
memset(ying_flag, 0, ying_length + 1);
memset(yang_flag, 0, yang_length + 1);
search_range = (search_range/2) - 1;
if (search_range < 0) search_range = 0;
// Looking only within the search range, count and flag the matched pairs.
common_chars = 0;
for (i = 0; i < ying_length; i++) {
lowlim = (i >= search_range) ? i - search_range : 0;
hilim = (i + search_range <= yang_length-1) ? (i + search_range) : yang_length-1;
for (j = lowlim; j <= hilim; j++) {
if (!yang_flag[j] && yang[j] == ying[i]) {
yang_flag[j] = 1;
ying_flag[i] = 1;
common_chars++;
break;
}
}
}
// If no characters in common - return
if (!common_chars) return 0;
// Count the number of transpositions
k = trans_count = 0;
for (i = 0; i < ying_length; i++) {
if (ying_flag[i]) {
for (j = k; j < yang_length; j++) {
if (yang_flag[j]) {
k = j + 1;
break;
}
}
if (ying[i] != yang[j]) {
trans_count++;
}
}
}
trans_count /= 2;
// adjust for similarities in nonmatched characters
// Main weight computation.
weight= common_chars / ((double) ying_length) + common_chars / ((double) yang_length)
+ ((double) (common_chars - trans_count)) / ((double) common_chars);
weight /= 3.0;
// Continue to boost the weight if the strings are similar
if (winklerize && weight > 0.7 && ying_length > 3 && yang_length > 3) {
// Adjust for having up to the first 4 characters in common
j = (min_len >= 4) ? 4 : min_len;
for (i=0; ((i<j) && (ying[i] == yang[i]) && (NOTNUM(ying[i]))); i++);
if (i) {
weight += i * 0.1 * (1.0 - weight);
}
/* Optionally adjust for long strings. */
/* After agreeing beginning chars, at least two more must agree and
the agreeing characters must be > .5 of remaining characters.
*/
if ((long_tolerance) && (min_len>4) && (common_chars>i+1) && (2*common_chars>=min_len+i)) {
if (NOTNUM(ying[0])) {
weight += (double) (1.0-weight) *
((double) (common_chars-i-1) / ((double) (ying_length+yang_length-i*2+2)));
}
}
}
return weight;
}
//double strcmp95(char *ying, char *yang, long y_length, int *ind_c[])
double strcmp95_modified (const char *ying, const char *yang)
{
/* Arguments:
ying and yang are pointers to the 2 strings to be compared. The strings
need not be NUL-terminated strings because the length is passed.
y_length is the length of the strings.
ind_c is an array that is used to define whether certain options should be
activated. A nonzero value indicates the option is deactivated.
The options are:
ind_c[0] Increase the probability of a match when the number of matched
characters is large. This option allows for a little more
tolerance when the strings are large. It is not an appropriate
test when comparing fixed length fields such as phone and
social security numbers.
ind_c[1] All lower case characters are converted to upper case prior
to the comparison. Disabling this feature means that the lower
case string "code" will not be recognized as the same as the
upper case string "CODE". Also, the adjustment for similar
characters section only applies to uppercase characters.
The suggested values are all zeros for character strings such as names. */
static int pass=0, adjwt[91][91];
static const unsigned char sp[39][2] =
{ {'A','E'}, {'A','I'}, {'A','O'}, {'A','U'}, {'B','V'}, {'E','I'}, {'E','O'}, {'E','U'},
{'I','O'}, {'I','U'}, {'O','U'}, {'I','Y'}, {'E','Y'}, {'C','G'}, {'E','F'},
{'W','U'}, {'W','V'}, {'X','K'}, {'S','Z'}, {'X','S'}, {'Q','C'}, {'U','V'},
{'M','N'}, {'L','I'}, {'Q','O'}, {'P','R'}, {'I','J'}, {'2','Z'}, {'5','S'},
{'8','B'}, {'1','I'}, {'1','L'}, {'0','O'}, {'0','Q'}, {'C','K'}, {'G','J'},
{'E',' '}, {'Y',' '}, {'S',' '}
};
char ying_hold[MAX_VAR_SIZE],
yang_hold[MAX_VAR_SIZE],
ying_flag[MAX_VAR_SIZE],
yang_flag[MAX_VAR_SIZE];
double weight, Num_sim;
long minv, search_range, lowlim, ying_length,
hilim, N_trans, Num_com, yang_length;
int yl1, /*yi_st,*/ N_simi;
register int i, j, k;
/* Initialize the adjwt array on the first call to the function only.
The adjwt array is used to give partial credit for characters that
may be errors due to known phonetic or character recognition errors.
A typical example is to match the letter "O" with the number "0" */
if (!pass) {
pass = 1;
for (i=0; i<91; i++) for (j=0; j<91; j++) adjwt[i][j] = 0;
for (i=0; i<36; i++) {
adjwt[sp[i][0]][sp[i][1]] = 3;
adjwt[sp[i][1]][sp[i][0]] = 3;
} }
//modified by edward
#if 0
// If either string is blank - return - added in Version 2 */
if (!strncmp(ying,NULL60,y_length)) return(0.0);
if (!strncmp(yang,NULL60,y_length)) return(0.0);
if(ying[0] == '\0' || yang[0] == '\0') return(0.0);
/* Identify the strings to be compared by stripping off all leading and
trailing spaces. */
k = y_length - 1;
for(j = 0;((ying[j]==' ') && (j < k));j++);
//for(i = k;((ying[i]==' ') && (i > 0));i--);
for(i=k;((ying[i]!='\0') && (i > 0));i--);
ying_length = i + 1 - j;
yi_st = j;
for(j = 0;((yang[j]==' ') && (j < k));j++);
//for(i = k;((yang[i]==' ') && (i > 0));i--);
for(i = k;((yang[i]!='\0') && (i > 0));i--);
yang_length = i + 1 - j;
#endif
//added by edward
ying_length = strlen(ying) ;
yang_length = strlen(yang) ;
//ying_hold[0]=yang_hold[0]=0;
//memcpy(ying_hold,&ying[yi_st],ying_length);
//memcpy(yang_hold,&yang[j],yang_length);
//memcpy(ying_hold, ying, ying_length);
//memcpy(yang_hold, yang, yang_length);
strcpy(ying_hold, ying);
strcpy(yang_hold, yang);
if (ying_length > yang_length) {
search_range = ying_length;
minv = yang_length;
}
else {
search_range = yang_length;
minv = ying_length;
}
/* If either string is blank - return */
/* if (!minv) return(0.0); removed in version 2 */
/* Blank out the flags */
ying_flag[0] = yang_flag[0] = 0;
strncat(ying_flag,NULL60,search_range);
strncat(yang_flag,NULL60,search_range);
search_range = (search_range/2) - 1;
if (search_range < 0) search_range = 0; /* added in version 2 */
/* Convert all lower case characters to upper case. */
//deanotated by edward
//if (!ind_c[1]) {
for (i = 0;i < ying_length;i++) if (islower(ying_hold[i])) ying_hold[i] -= 32;
for (j = 0;j < yang_length;j++) if (islower(yang_hold[j])) yang_hold[j] -= 32;
//}
/* Looking only within the search range, count and flag the matched pairs. */
Num_com = 0;
yl1 = yang_length - 1;
for (i = 0;i < ying_length;i++) {
lowlim = (i >= search_range) ? i - search_range : 0;
hilim = ((i + search_range) <= yl1) ? (i + search_range) : yl1;
for (j = lowlim;j <= hilim;j++) {
if ((yang_flag[j] != '1') && (yang_hold[j] == ying_hold[i])) {
yang_flag[j] = '1';
ying_flag[i] = '1';
Num_com++;
break;
} } }
/* If no characters in common - return */
if (!Num_com) return(0.0);
/* Count the number of transpositions */
k = N_trans = 0;
for (i = 0;i < ying_length;i++) {
if (ying_flag[i] == '1') {
for (j = k;j < yang_length;j++) {
if (yang_flag[j] == '1') {
k = j + 1;
break;
} }
if (ying_hold[i] != yang_hold[j]) N_trans++;
} }
N_trans = N_trans / 2;
/* adjust for similarities in nonmatched characters */
N_simi = 0;
if (minv > Num_com) {
for (i = 0;i < ying_length;i++) {
if (ying_flag[i] == ' ' && INRANGE(ying_hold[i])) {
for (j = 0;j < yang_length;j++) {
if (yang_flag[j] == ' ' && INRANGE(yang_hold[j])) {
if (adjwt[(unsigned char)ying_hold[i]][(unsigned char)yang_hold[j]] > 0) {
N_simi += adjwt[(unsigned char)ying_hold[i]][(unsigned char)yang_hold[j]];
yang_flag[j] = '2';
break;
} } } } } }
Num_sim = ((double) N_simi)/10.0 + Num_com;
/* Main weight computation. */
weight= Num_sim / ((double) ying_length) + Num_sim / ((double) yang_length) + ((double) (Num_com - N_trans)) / ((double) Num_com);
weight = weight / 3.0;
/* Continue to boost the weight if the strings are similar */
if (weight > 0.7) {
/* Adjust for having up to the first 4 characters in common */
j = (minv >= 4) ? 4 : minv;
for (i=0;((i<j)&&(ying_hold[i]==yang_hold[i])&&(NOTNUM(ying_hold[i])));i++);
if (i) weight += i * 0.1 * (1.0 - weight);
/* Optionally adjust for long strings. */
/* After agreeing beginning chars, at least two more must agree and
the agreeing characters must be > .5 of remaining characters. */
//deanotated by edward
//if ((!ind_c[0]) && (minv>4) && (Num_com>i+1) && (2*Num_com>=minv+i))
if ((minv>4) && (Num_com>i+1) && (2*Num_com>=minv+i))
if (NOTNUM(ying_hold[0]))
weight += (double) (1.0-weight) *
((double) (Num_com-i-1) / ((double) (ying_length+yang_length-i*2+2)));
}
return(weight);
} /* strcmp95 */
