ferret 0.9.1 → 0.9.2

data/ext/similarity.c

@@ -29,58 +29,61 @@ setup_endian()
 float byte_to_float(uchar b)
 {
   char flt[4];
-  if (b == 0)
+  if (b == 0) {
     return 0.0;
-  int mantissa = b & 0x07;           // 0x07 =  7 = 0b00000111
-  int exponent = (b >> 3) & 0x1F;    // 0x1f = 31 = 0b00011111
-
-  if (!low_mid_bit) setup_endian();
-  flt[low_bit] = flt[low_mid_bit] = 0;
-  flt[high_mid_bit] = mantissa << 5;
-  flt[high_bit] = exponent + 48;
-  return *((float *)flt);
+  } else {
+    int mantissa = b & 0x07;           // 0x07 =  7 = 0b00000111
+    int exponent = (b >> 3) & 0x1F;    // 0x1f = 31 = 0b00011111
+
+    if (!low_mid_bit) setup_endian();
+    flt[low_bit] = flt[low_mid_bit] = 0;
+    flt[high_mid_bit] = mantissa << 5;
+    flt[high_bit] = exponent + 48;
+    return *((float *)flt);
+  }
 }
 
 uchar float_to_byte(float f)
 {
-  if (f <= 0.0)
+  if (f <= 0.0) {
     return 0;
+  } else {
+    char *bits = (char *)&f;
+    int mantissa = (bits[high_mid_bit] & 0xEf) >> 5;
+    int exponent = (bits[high_bit] - 48);
+
+    if (exponent > 0x1f) {
+      exponent = 0x1f;   // 0x1f = 31 = 0b00011111
+      mantissa = 0x07;   // 0x07 =  7 = 0b00000111
+    }
 
-  char *bits = (char *)&f;
-  int mantissa = (bits[high_mid_bit] & 0xEf) >> 5;
-  int exponent = (bits[high_bit] - 48);
-
-  if (exponent > 0x1f) {
-    exponent = 0x1f;   // 0x1f = 31 = 0b00011111
-    mantissa = 0x07;   // 0x07 =  7 = 0b00000111
-  }
+    if (exponent < 0) {
+      exponent = 0;
+      mantissa = 1;
+    }
 
-  if (exponent < 0) {
-    exponent = 0;
-    mantissa = 1;
+    return ((exponent<<3) | mantissa);
   }
-
-  return ((exponent<<3) | mantissa);
 }
 
 float simdef_length_norm(Similarity *s, char *field, int num_terms)
 {
-  return 1.0 / sqrt(num_terms);  
+  return (float)(1.0 / sqrt(num_terms));
 }
 
 float simdef_query_norm(struct Similarity *s, float sum_of_squared_weights)
 {
-  return 1.0 / sqrt(sum_of_squared_weights);
+  return (float)(1.0 / sqrt(sum_of_squared_weights));
 }
 
 float simdef_tf(struct Similarity *s, float freq)
 {
-  return sqrt(freq);
+  return (float)sqrt(freq);
 }
 
 float simdef_sloppy_freq(struct Similarity *s, int distance)
 {
-  return 1.0 / (float)(distance + 1);
+  return (float)(1.0 / (double)(distance + 1));
 }
 
 float simdef_idf_term(struct Similarity *s, Term *term, Searcher *searcher)
@@ -100,12 +103,12 @@ float simdef_idf_phrase(struct Similarity *s, Term **terms, int tcnt, Searcher *
 
 float simdef_idf(struct Similarity *s, int doc_freq, int num_docs)
 {
-  return log((float)num_docs/(float)(doc_freq+1)) + 1.0;
+  return (float)(log((float)num_docs/(float)(doc_freq+1)) + 1.0);
 }
 
 float simdef_coord(struct Similarity *s, int overlap, int max_overlap)
 {
-  return (float)overlap / (float)max_overlap;
+  return (float)((double)overlap / (double)max_overlap);
 }
 
 float simdef_decode_norm(struct Similarity *s, uchar b)
@@ -113,16 +116,33 @@ float simdef_decode_norm(struct Similarity *s, uchar b)
   return s->norm_table[b];
 }
 
-float simdef_encode_norm(struct Similarity *s, float f)
+uchar simdef_encode_norm(struct Similarity *s, float f)
 {
   return float_to_byte(f);
 }
 
-void simdef_destroy(void *p)
+void simdef_destroy(Similarity *s)
 {
-  // nothing to do here;
+  /* nothing to do here */
 }
 
+#ifdef WIN32
+static Similarity default_similarity = {
+  NULL,
+  {0},
+  &simdef_length_norm,
+  &simdef_query_norm,
+  &simdef_tf,
+  &simdef_sloppy_freq,
+  &simdef_idf_term,
+  &simdef_idf_phrase,
+  &simdef_idf,
+  &simdef_coord,
+  &simdef_decode_norm,
+  &simdef_encode_norm,
+  &simdef_destroy
+};
+#else
 static Similarity default_similarity = {
   data:NULL,
   length_norm:&simdef_length_norm,
@@ -137,6 +157,8 @@ static Similarity default_similarity = {
   encode_norm:&simdef_encode_norm,
   destroy:&simdef_destroy
 };
+#endif
+
 Similarity *sim_create_default()
 {
   int i;
@@ -147,17 +169,4 @@ Similarity *sim_create_default()
     default_similarity.data = &default_similarity;
   }
   return &default_similarity;
-
-//  s->length_norm = &simdef_length_norm;
-//  s->query_norm = &simdef_query_norm;
-//  s->tf = &simdef_tf;
-//  s->sloppy_freq = &simdef_sloppy_freq;
-//  s->idf_term = &simdef_idf_term;
-//  s->idf_phrase = &simdef_idf_phrase;
-//  s->idf = &simdef_idf;
-//  s->coord = &simdef_coord;
-//  s->decode_norm = &simdef_decode_norm;
-//  s->encode_norm = &simdef_encode_norm;
-//  s->destroy = &simdef_destroy;
-//  return s;
 }

data/ext/similarity.h

@@ -16,7 +16,7 @@ typedef struct Term {
 
 Term *term_clone(Term *term);
 Term *term_create(const char *field, char *text);
-void term_destroy(void *p);
+void term_destroy(Term *self);
 int term_cmp(void *t1, void *t2);
 int term_eq(const void *t1, const void *t2);
 unsigned int term_hash(const void *t);
@@ -43,8 +43,8 @@ struct Similarity {
   float (*idf)(Similarity *self, int doc_freq, int num_docs);
   float (*coord)(Similarity *self, int overlap, int max_overlap);
   float (*decode_norm)(Similarity *self, uchar b);
-  float (*encode_norm)(Similarity *self, float f);
-  void  (*destroy)(void *p);
+  uchar (*encode_norm)(Similarity *self, float f);
+  void  (*destroy)(Similarity *self);
 };
 
 #define sim_length_norm(msim, field, num_terms) msim->length_norm(msim, field, num_terms)

data/ext/sort.c

@@ -92,6 +92,43 @@ void sort_field_destroy(void *p)
   free(p);
 }
 
+/*
+ * field:<type>!
+ */
+char *sort_field_to_s(SortField *self)
+{
+  char *str;
+  char *type = NULL;
+  switch (self->type) {
+    case SORT_TYPE_SCORE:
+      type = "<SCORE>";
+      break;
+    case SORT_TYPE_DOC:
+      type = "<DOC>";
+      break;
+    case SORT_TYPE_INTEGER:
+      type = "<integer>";
+      break;
+    case SORT_TYPE_FLOAT:
+      type = "<float>";
+      break;
+    case SORT_TYPE_STRING:
+      type = "<string>";
+      break;
+    case SORT_TYPE_AUTO:
+      type = "<auto>";
+      break;
+  }
+  if (self->field) {
+    str = ALLOC_N(char, 10 + strlen(self->field) + strlen(type));
+    sprintf(str, "%s:%s%s", self->field, type, (self->reverse ? "!" : ""));
+  } else {
+    str = ALLOC_N(char, 10 + strlen(type));
+    sprintf(str, "%s%s", type, (self->reverse ? "!" : ""));
+  }
+  return str;
+}
+
 /***************************************************************************
  * ScoreSortField
  ***************************************************************************/
@@ -113,25 +150,27 @@ SortField *sort_field_score_create(bool reverse)
 }
 
 SortField SORT_FIELD_SCORE = {
-  field:NULL,
-  type:SORT_TYPE_SCORE,
-  reverse:false,
-  index:NULL,
-  compare:&sf_score_compare,
-  create_index:NULL,
-  destroy_index:NULL,
-  handle_term:NULL
+  MUTEX_INITIALIZER,
+  /* field */NULL,
+  /* type */SORT_TYPE_SCORE,
+  /* reverse */false,
+  /* index */NULL,
+  /* compare */&sf_score_compare,
+  /* create_index */NULL,
+  /* destroy_index */NULL,
+  /* handle_term */NULL
 };
 
 SortField SORT_FIELD_SCORE_REV = {
-  field:NULL,
-  type:SORT_TYPE_SCORE,
-  reverse:true,
-  index:NULL,
-  compare:&sf_score_compare,
-  create_index:NULL,
-  destroy_index:NULL,
-  handle_term:NULL
+  MUTEX_INITIALIZER,
+  /* field */NULL,
+  /* type */SORT_TYPE_SCORE,
+  /* reverse */true,
+  /* index */NULL,
+  /* compare */&sf_score_compare,
+  /* create_index */NULL,
+  /* destroy_index */NULL,
+  /* handle_term */NULL
 };
 
 /**************************************************************************
@@ -155,25 +194,27 @@ SortField *sort_field_doc_create(bool reverse)
 }
 
 SortField SORT_FIELD_DOC = {
-  field:NULL,
-  type:SORT_TYPE_DOC,
-  reverse:false,
-  index:NULL,
-  compare:&sf_doc_compare,
-  create_index:NULL,
-  destroy_index:NULL,
-  handle_term:NULL
+  MUTEX_INITIALIZER,
+  /* field */NULL,
+  /* type */SORT_TYPE_DOC,
+  /* reverse */false,
+  /* index */NULL,
+  /* compare */&sf_doc_compare,
+  /* create_index */NULL,
+  /* destroy_index */NULL,
+  /* handle_term */NULL
 };
 
 SortField SORT_FIELD_DOC_REV = {
-  field:NULL,
-  type:SORT_TYPE_DOC,
-  reverse:true,
-  index:NULL,
-  compare:&sf_doc_compare,
-  create_index:NULL,
-  destroy_index:NULL,
-  handle_term:NULL
+  MUTEX_INITIALIZER,
+  /* field */NULL,
+  /* type */SORT_TYPE_DOC,
+  /* reverse */true,
+  /* index */NULL,
+  /* compare */&sf_doc_compare,
+  /* create_index */NULL,
+  /* destroy_index */NULL,
+  /* handle_term */NULL
 };
 
 /***************************************************************************
@@ -278,11 +319,15 @@ typedef struct StringIndex {
 int sf_string_compare(void *index_ptr, Hit *hit1, Hit *hit2)
 {
   StringIndex *index = (StringIndex *)index_ptr;
+  return strcoll(index->values[index->index[hit1->doc]],
+    index->values[index->index[hit2->doc]]);
+  /*
   int val1 = index->index[hit1->doc];
   int val2 = index->index[hit2->doc];
   if (val1 > val2) return 1;
   else if (val1 < val2) return -1;
   else return 0;
+  */
 }
 
 void *sf_string_create_index(int size)
@@ -346,7 +391,7 @@ void sort_field_auto_evaluate(SortField *sf, char *text)
 {
   int int_val;
   float float_val;
-  int text_len = 0, scan_len = 0;
+  size_t text_len = 0, scan_len = 0;
 
   text_len = strlen(text);
   sscanf(text, "%d%n", &int_val, &scan_len);
@@ -362,7 +407,6 @@ void sort_field_auto_evaluate(SortField *sf, char *text)
   }
 }
 
-
 SortField *sort_field_auto_create(char *field, bool reverse)
 {
   return sort_field_alloc(field, SORT_TYPE_AUTO, reverse);
@@ -502,8 +546,8 @@ Sorter *sorter_create(int size)
 
 bool fshq_less_than(void *hit1, void *hit2)
 {
-  printf("Whoops, shouldn't call this.\n");
   int cmp = 0;
+  printf("Whoops, shouldn't call this.\n");
   if (cmp != 0) {
     return cmp;
   } else {
@@ -570,11 +614,11 @@ Hit *fshq_pq_pop(PriorityQueue *pq)
 
 inline void fshq_pq_up(PriorityQueue *pq)
 {
-	int i,j;
-	i = pq->count;
-	j = i >> 1;
   Hit **heap = (Hit **)pq->heap;
-  Hit *node = heap[i];
+  Hit *node;
+	int i = pq->count;
+	int j = i >> 1;
+  node = heap[i];
 
 	while ((j > 0) && fshq_lt(heap[0], node, heap[j])) {
 		heap[i] = heap[j];
@@ -584,16 +628,23 @@ inline void fshq_pq_up(PriorityQueue *pq)
   heap[i] = node;
 }
 
-void fshq_pq_push(PriorityQueue *pq, void *elem)
+void fshq_pq_insert(PriorityQueue *pq, Hit *hit)
 {
-  pq->count++;
-  pq->heap[pq->count] = elem;
-  fshq_pq_up(pq);
+  if (pq->count < pq->size) {
+    Hit *new_hit = ALLOC(Hit);
+    memcpy(new_hit, hit, sizeof(Hit));
+    pq->count++;
+    pq->heap[pq->count] = new_hit;
+    fshq_pq_up(pq);
+  } else if (pq->count > 0 &&
+      fshq_lt((Hit *)pq->heap[0], (Hit *)pq->heap[1], hit)) {
+    memcpy(pq->heap[1], hit, sizeof(Hit));
+    fshq_pq_down(pq);
+  }
 }
 
-void fshq_pq_destroy(void *p)
+void fshq_pq_destroy(PriorityQueue *self)
 {
-  PriorityQueue *self = (PriorityQueue *)p; 
   sorter_destroy(self->heap[0]);
   pq_destroy(self);
 }
@@ -634,21 +685,18 @@ Sort *sort_create()
 void sort_clear(Sort *self)
 {
   int i;
-  for (i = 0; i < self->sf_cnt; i++) {
-    sort_field_destroy(self->sort_fields[i]);
+  if (self->destroy_all) {
+    for (i = 0; i < self->sf_cnt; i++) {
+      sort_field_destroy(self->sort_fields[i]);
+    }
   }
   self->sf_cnt = 0;
 }
 
 void sort_destroy(void *p)
 {
-  int i;
   Sort *self = (Sort *)p;
-  if (self->destroy_all) {
-    for (i = 0; i < self->sf_cnt; i++) {
-      sort_field_destroy(self->sort_fields[i]);
-    }
-  }
+  sort_clear(self);
   free(self->sort_fields);
   free(self);
 }
@@ -664,3 +712,34 @@ void sort_add_sort_field(Sort *self, SortField *sf)
   self->sf_cnt++;
 }
 
+char *sort_to_s(Sort *self)
+{
+  int i, len = 20;
+  char *s;
+  char *str;
+  char **sf_strs = ALLOC_N(char *, self->sf_cnt);
+
+  for (i = 0; i < self->sf_cnt; i++) {
+    sf_strs[i] = s = sort_field_to_s(self->sort_fields[i]);
+    len += (int)strlen(s) + 2;
+  }
+
+  str = ALLOC_N(char, len);
+  s = "Sort[";
+  len = (int)strlen(s);
+  memcpy(str, s, len);
+
+  s = str + len;
+  for (i = 0; i < self->sf_cnt; i++) {
+    sprintf(s, "%s, ", sf_strs[i]);
+    s += (int)strlen(s);
+    free(sf_strs[i]);
+  }
+  free(sf_strs);
+
+  if (self->sf_cnt > 0) {
+    s -= 2;
+  }
+  sprintf(s, "]");
+  return str;
+}