lulu 0.0.2 → 0.0.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Y2E5ZGRjNDExMGVlYWQwNjUyNzYzYmFhNWFlNTU1OTVkZWM0ZjY5OA==
+    ZWFjMGJjNzk1NGM5YzRjYTQxYmZkMDUxMTA4OWJhZmI1YjMyYzZjYg==
   data.tar.gz: !binary |-
-    MGQ2NDZjZTk5Njc1NzE4OWM5ZDJiNmNkZDAwNTlkNjMzYWY4NmJkZg==
+    YTRkMjY0YzcyNWVlZWVjN2I2NWI5MmE3ZjI3NGE0M2Y1NzkxMzhkMQ==
 SHA512:
   metadata.gz: !binary |-
-    NTkzODkzOTUxNGIyYjY2OTNjMmUxYjA3MTI0MDUxNDU4MDEwMzJjYTcxMzU5
-    NTVhZmVkNjZjMzMyYzIyYjVmOTUzZjM2MmVhMTZjNWI0MTIzYmI2MTcwYmNh
-    NjE5MzU5NDVmNTRhMjQwN2JmZjJhMDQ0MGUwMTgxNjYxYzVlYTU=
+    NTE3YmQxOTljNzA2MjU5MDljYmRkZGE1ZjNjMWIyNTgyNzczYzZmNzM2ODdh
+    Y2M2Mzg4NDk1OGM5MzNmNjgzZTY5ZmYyZGJkNzg0MGRmYmYwNDBkYzU0MDc5
+    ZWM2NmRhNTk0MzZhZWFlZjMzOWI2MjkzYWVlNmU0Y2E2YjFmYWE=
   data.tar.gz: !binary |-
-    MWVjNjUxNTgwZGJiNjVkYWMyZWY3NWVmMDUxY2ZkOWQzMWRiNDYxNWZkNzlj
-    MWZmZTQyMDU5MmM1Nzk2ZGFmOTk5ZGEzYWI0MDAwNTRjOGFiNWVlMDY5YzY5
-    NDk4Mzc4ZjIyNWU3ZjljZWRmNGNjNTFlOWZhOGE4ZGQwODVjYmM=
+    NTFhMzc0MDY1YjhjMWUwYjE1ZTgwY2FlZTAyOTk0NTI4MmFkNGNiMzkxYjAw
+    NTY1M2Q5ODQ4YThmZjNhYzRkN2UxYjk2OTk0OTVjOWQ0ODQ1NjRhM2U1NjA2
+    NzBjYmMwNWE3NGEyODA2MDBjYjM2MjNmMTM5N2UwMjFlN2Q1ZTc=

data/.gitignore

@@ -2,7 +2,7 @@
 *.rbc
 *.o
 *.d
-.bundle
+*.bundle
 .config
 .yardoc
 .idea/

data/ext/lulu/extconf.rb

@@ -3,4 +3,7 @@ require 'mkmf'
 # Turn off warnings about declarations mixed with code.
 $CFLAGS += ' -std=c99 -Wno-declaration-after-statement'
 
+# Select Ruby gem code
+$CFLAGS += ' -DLULU_GEM'
+
 create_makefile('lulu/lulu')

data/ext/lulu/lulu.c

@@ -53,7 +53,7 @@ void free_marker_list(MARKER_LIST *list) {
     Free(list);
 }
 
-void add_marker(MARKER_LIST *list, COORD x, COORD y, SIZE size) {
+void add_marker(MARKER_LIST *list, MARKER_COORD x, MARKER_COORD y, MARKER_SIZE size) {
     if (list->size >= list->max_size) {
         list->max_size = 4 + 2 * list->max_size;
         RenewArray(list->markers, list->max_size);
@@ -85,12 +85,12 @@ void compress(MARKER_LIST *list) {
 // -------- Ruby API implementation --------------------------------------------
 
 static void rb_api_free_marker_list(void *list) {
-	free_marker_list(list);
+    free_marker_list(list);
 }
 
 static VALUE rb_api_new_marker_list(VALUE klass) {
-	MARKER_LIST *list = new_marker_list();
-	return Data_Wrap_Struct(klass, 0, rb_api_free_marker_list, list);
+    MARKER_LIST *list = new_marker_list();
+    return Data_Wrap_Struct(klass, 0, rb_api_free_marker_list, list);
 }
 
 #define MARKER_LIST_FOR_VALUE_DECL(Var) MARKER_LIST *Var; Data_Get_Struct(Var ## _value, MARKER_LIST, Var)
@@ -247,8 +247,8 @@ static struct ft_entry {
 #define STRING_CONST_TABLE_ENTRY(Name) { #Name, Name }
 
 static struct sct_entry {
-  const char *name;
-  const char *val;
+    const char *name;
+    const char *val;
 } string_const_table[] = {
     STRING_CONST_TABLE_ENTRY(EXT_VERSION)
 };

data/ext/lulu/marker.c

@@ -16,24 +16,24 @@
 void mr_info_init(MARKER_INFO *info) {
     info->kind = CIRCLE;
     info->scale = 1;
-	info->c = SQRT_1_PI;
+    info->c = SQRT_1_PI;
 }
 
-void mr_info_set(MARKER_INFO *info, MARKER_KIND kind, DISTANCE scale) {
+void mr_info_set(MARKER_INFO *info, MARKER_KIND kind, MARKER_DISTANCE scale) {
     info->kind = kind;
     info->scale = scale;
-	info->c = scale * (kind == SQUARE ? 0.5 : SQRT_1_PI);
+    info->c = scale * (kind == SQUARE ? 0.5 : SQRT_1_PI);
 }
 
 void mr_init(MARKER *markers, int n_markers) {
-	for (int i = 0; i < n_markers; i++) {
-		MARKER *marker = markers + i;
-		marker->deleted_p = 0;
-		marker->size = 0;
-		marker->r = 0;
-		marker->x = marker->y = marker->x_sum = marker->y_sum = 0;
-		mr_reset_parts(marker);
-	}
+    for (int i = 0; i < n_markers; i++) {
+        MARKER *marker = markers + i;
+        marker->deleted_p = 0;
+        marker->size = 0;
+        marker->r = 0;
+        marker->x = marker->y = marker->x_sum = marker->y_sum = 0;
+        mr_reset_parts(marker);
+    }
 }
 
 void mr_reset_parts(MARKER *marker) {
@@ -41,71 +41,71 @@ void mr_reset_parts(MARKER *marker) {
     marker->part_b = 0;
 }
 
-void mr_set(MARKER_INFO *info, MARKER *marker, COORD x, COORD y, SIZE size) {
-	mr_init(marker, 1);
-	marker->size = size;
-	marker->r = size_to_radius(info, size);
-	marker->x = x;
-	marker->y = y;
-	marker->x_sum = x * size;
-	marker->y_sum = y * size;
+void mr_set(MARKER_INFO *info, MARKER *marker, MARKER_COORD x, MARKER_COORD y, MARKER_SIZE size) {
+    mr_init(marker, 1);
+    marker->size = size;
+    marker->r = size_to_radius(info, size);
+    marker->x = x;
+    marker->y = y;
+    marker->x_sum = x * size;
+    marker->y_sum = y * size;
 }
 
 void mr_merge(MARKER_INFO *info, MARKER *markers, int i_merged, int ia, int ib) {
     MARKER *merged = markers + i_merged;
     MARKER *a = markers + ia;
     MARKER *b = markers + ib;
-	merged->deleted_p = 0;
-	merged->size = a->size + b->size;
-	merged->r = size_to_radius(info, merged->size);
-	merged->x_sum = a->x_sum + b->x_sum;
-	merged->y_sum = a->y_sum + b->y_sum;
-	merged->x = merged->x_sum / merged->size;
-	merged->y = merged->y_sum / merged->size;
-	merged->part_a = ia;
-	merged->part_b = ib;
+    merged->deleted_p = 0;
+    merged->size = a->size + b->size;
+    merged->r = size_to_radius(info, merged->size);
+    merged->x_sum = a->x_sum + b->x_sum;
+    merged->y_sum = a->y_sum + b->y_sum;
+    merged->x = merged->x_sum / merged->size;
+    merged->y = merged->y_sum / merged->size;
+    merged->part_a = ia;
+    merged->part_b = ib;
 }
 
-DISTANCE size_to_radius(MARKER_INFO *info, SIZE size) {
-	return info->c * sqrt(size);
+MARKER_DISTANCE size_to_radius(MARKER_INFO *info, MARKER_SIZE size) {
+    return info->c * sqrt(size);
 }
 
-DISTANCE mr_distance(MARKER_INFO *info, MARKER *a, MARKER *b) {
-	if (info->kind == SQUARE) {
-		double r_sum = mr_r(a) + mr_r(b);
-		double dx = fabs(mr_x(b) - mr_x(a)) - r_sum;
-		double dy = fabs(mr_y(b) - mr_y(a)) - r_sum;
-		DISTANCE d = dx < 0 && dy < 0 ? fmax(dx, dy) : sqrt(dx * dx + dy * dy);
-		return d;
-	}
-	double dx = mr_x(b) - mr_x(a);
-	double dy = mr_y(b) - mr_y(a);
-	return sqrt(dx * dx + dy * dy) - mr_r(a) - mr_r(b);
+MARKER_DISTANCE mr_distance(MARKER_INFO *info, MARKER *a, MARKER *b) {
+    if (info->kind == SQUARE) {
+        MARKER_DISTANCE r_sum = mr_r(a) + mr_r(b);
+        MARKER_DISTANCE dx = fabs(mr_x(b) - mr_x(a)) - r_sum;
+        MARKER_DISTANCE dy = fabs(mr_y(b) - mr_y(a)) - r_sum;
+        MARKER_DISTANCE d = dx < 0 && dy < 0 ? fmax(dx, dy) : sqrt(dx * dx + dy * dy);
+        return d;
+    }
+    MARKER_DISTANCE dx = mr_x(b) - mr_x(a);
+    MARKER_DISTANCE dy = mr_y(b) - mr_y(a);
+    return sqrt(dx * dx + dy * dy) - mr_r(a) - mr_r(b);
 }
 
 void get_marker_array_extent(MARKER *a, int n_markers, MARKER_EXTENT *ext) {
-	if (n_markers > 0) {
-		double ew = mr_w(a);
-		double ee = mr_e(a);
-		double es = mr_s(a);
-		double en = mr_n(a);
-		for (int i = 1; i < n_markers; i++) {
-			double w = mr_w(a + i);
-			double e = mr_e(a + i);
-			double s = mr_s(a + i);
-			double n = mr_n(a + i);
-			if (w < ew)
-				ew = w;
-			if (e > ee)
-				ee = e;
-			if (s < es)
-				es = s;
-			if (n > en)
-				en = n;
-		}
-		ext->x = ew;
-		ext->y = es;
-		ext->w = ee - ew;
-		ext->h = en - es;
-	}
+    if (n_markers > 0) {
+        MARKER_DISTANCE ew = mr_w(a);
+        MARKER_DISTANCE ee = mr_e(a);
+        MARKER_DISTANCE es = mr_s(a);
+        MARKER_DISTANCE en = mr_n(a);
+        for (int i = 1; i < n_markers; i++) {
+            MARKER_DISTANCE w = mr_w(a + i);
+            MARKER_DISTANCE e = mr_e(a + i);
+            MARKER_DISTANCE s = mr_s(a + i);
+            MARKER_DISTANCE n = mr_n(a + i);
+            if (w < ew)
+                ew = w;
+            if (e > ee)
+                ee = e;
+            if (s < es)
+                es = s;
+            if (n > en)
+                en = n;
+        }
+        ext->x = ew;
+        ext->y = es;
+        ext->w = ee - ew;
+        ext->h = en - es;
+    }
 }

data/ext/lulu/marker.h

@@ -8,46 +8,46 @@
 #ifndef MARKER_H_
 #define MARKER_H_
 
-typedef double COORD;
-typedef double DISTANCE;
+typedef double MARKER_COORD;
+typedef double MARKER_DISTANCE;
 /**
  * Size of population represented by the marker.  For
  * discrete populations, this can be an unsigned int.
  */
-typedef double SIZE;
+typedef double MARKER_SIZE;
 
 typedef struct marker_s {
-	SIZE size;
-	DISTANCE r;
-	COORD x, y, x_sum, y_sum;
-	int part_a;
-	unsigned deleted_p:1, part_b:31;
+    MARKER_SIZE size;
+    MARKER_DISTANCE r;
+    MARKER_COORD x, y, x_sum, y_sum;
+    int part_a;
+    unsigned deleted_p:1, part_b:31;
 } MARKER;
 
 typedef enum marker_kind_e {
-	CIRCLE,
-	SQUARE,
+    CIRCLE,
+    SQUARE,
 } MARKER_KIND;
 
 /**
  * Holds parameters of the distance function and merging.
  */
 typedef struct marker_type_info_s {
-	MARKER_KIND kind;
-	// User scale applied to radii of markers during distance computation.
-	DISTANCE scale;
-	// A scale factor that depends on both kind and user scale.
-	DISTANCE c;
+    MARKER_KIND kind;
+    // User scale applied to radii of markers during distance computation.
+    MARKER_DISTANCE scale;
+    // A scale factor that depends on both kind and user scale.
+    MARKER_DISTANCE c;
 } MARKER_INFO;
 
 #define MARKER_INFO_DECL(I) MARKER_INFO I[1]; mr_info_init(I)
 
 typedef struct marker_extent_s {
-	COORD x, y, w, h;
+    MARKER_COORD x, y, w, h;
 } MARKER_EXTENT;
 
-#define mr_deleted_p(M)		((M)->deleted_p)
-#define mr_set_deleted(M)	do { (M)->deleted_p = 1; } while (0)
+#define mr_deleted_p(M)     ((M)->deleted_p)
+#define mr_set_deleted(M)   do { (M)->deleted_p = 1; } while (0)
 #define mr_merged(M)        ((M)->part_a >= 0)
 #define mr_x(M) ((M)->x)
 #define mr_y(M) ((M)->y)
@@ -60,11 +60,11 @@ typedef struct marker_extent_s {
 void mr_init(MARKER *marker, int n_markers);
 void mr_reset_parts(MARKER *marker);
 void mr_info_init(MARKER_INFO *info);
-void mr_info_set(MARKER_INFO *info, MARKER_KIND kind, DISTANCE scale);
-void mr_set(MARKER_INFO *info, MARKER *marker, COORD x, COORD y, SIZE size);
+void mr_info_set(MARKER_INFO *info, MARKER_KIND kind, MARKER_DISTANCE scale);
+void mr_set(MARKER_INFO *info, MARKER *marker, MARKER_COORD x, MARKER_COORD y, MARKER_SIZE size);
 void mr_merge(MARKER_INFO *info, MARKER *markers, int merged, int a, int b);
-DISTANCE mr_distance(MARKER_INFO *info, MARKER *a, MARKER *b);
-DISTANCE size_to_radius(MARKER_INFO *info, SIZE size);
+MARKER_DISTANCE mr_distance(MARKER_INFO *info, MARKER *a, MARKER *b);
+MARKER_DISTANCE size_to_radius(MARKER_INFO *info, MARKER_SIZE size);
 void get_marker_array_extent(MARKER *a, int n_markers, MARKER_EXTENT *ext);
 
 #endif /* MARKER_H_ */

data/ext/lulu/merger.c

@@ -34,158 +34,120 @@
  * overlapping markers in the original, unmerged set.
  */
 int merge_markers_fast(MARKER_INFO *info, MARKER *markers, int n_markers) {
-	int augmented_length = 2 * n_markers - 1;
-	NewArrayDecl(int, n_nghbr, augmented_length);
-	NewArrayDecl(DISTANCE, mindist, augmented_length);
-	NewArrayDecl(int, inv_nghbr_head, augmented_length);
-	NewArrayDecl(int, inv_nghbr_next, augmented_length);
-	NewArrayDecl(int, tmp, augmented_length); // Too big
-	// Do not free the following array!  It's owned by the priority queue.
-	NewArrayDecl(int, heap, augmented_length); // Too big
-
-	// Specialized quadtree supports finding closest marker to any given one.
-	QUADTREE_DECL(qt);
-
-	// Priority queue keyed on distances of overlapping pairs of markers.
-	PRIORITY_QUEUE_DECL(pq);
-
-	/// Extent of markers in the domain.
-	MARKER_EXTENT ext[1];
-
-	// Get a bounding box for the whole collection of markers.
-	get_marker_array_extent(markers, n_markers, ext);
-
-	// Set up the quadtree with the bounding box. Choose tree depth heuristically.
-	int max_depth = high_bit_position(n_markers) / 4 + 3;
-	qt_setup(qt, max_depth, ext->x, ext->y, ext->w, ext->h, info);
-
-	// Insert all the markers in the quadtree.
-	for (int i = 0; i < n_markers; i++)
-		qt_insert(qt, markers + i);
-
-	// Set all the inverse nearest neighbor links to null.
-	for (int i = 0; i < augmented_length; i++)
-		inv_nghbr_head[i] = inv_nghbr_next[i] = -1;
-
-	// Initialize the heap by adding an index for each overlapping pair. The
-	// The heap holds indices into the array of min-distance keys. An index for
-	// pair a->bis added iff markers with indices a and b overlap and b < a.
-	int heap_size = 0;
-	for (int a = 0; a < n_markers; a++) {
-		int b = qt_nearest_wrt(markers, qt, a);
-		if (0 <= b && b < a) {
-			n_nghbr[a] = b;
-			mindist[a] = mr_distance(info, markers + a, markers + b);
-			heap[heap_size++] = a;
-
-			// Here we are building a linked list of markers that have b as nearest.
-			inv_nghbr_next[a] = inv_nghbr_head[b];
-			inv_nghbr_head[b] = a;
-		}
-	}
-
-	// Now install the raw heap array into the priority queue. After this it's owned by the queue.
-	pq_set_up_heap(pq, heap, heap_size, mindist, augmented_length); // Too big
-
-	while (!pq_empty_p(pq)) {
-
-		// Get nearest pair from priority queue.
-		int a = pq_get_min(pq);
-		int b = n_nghbr[a];
-
-		// Delete both of the nearest pair from all data structures.
-		pq_delete(pq, b);
-		qt_delete(qt, markers + a);
-		qt_delete(qt, markers + b);
-		mr_set_deleted(markers + a);
-		mr_set_deleted(markers + b);
-
-		// Capture the inv lists of both a and b in tmp.
-		int tmp_size = 0;
-		for (int p = inv_nghbr_head[a]; p >= 0; p = inv_nghbr_next[p])
-			if (!markers[p].deleted_p)
-				tmp[tmp_size++] = p;
-		for (int p = inv_nghbr_head[b]; p >= 0; p = inv_nghbr_next[p])
-			if (!markers[p].deleted_p)
-				tmp[tmp_size++] = p;
-
-		// Create a new merged marker. Adding it after all others means
-		// nothing already in the heap could have it as nearest.
-		int aa = n_markers++;
-		mr_merge(info, markers, aa, a, b);
-
-		// Add to quadtree.
-		qt_insert(qt, markers + aa);
-
-		// Find nearest overlapping neighbor of the merged marker, if any.
-		int bb = qt_nearest_wrt(markers, qt, aa);
-		if (0 <= bb) {
-			n_nghbr[aa] = bb;
-			mindist[aa] = mr_distance(info, markers + aa, markers + bb);
-			pq_add(pq, aa);
-			inv_nghbr_next[aa] = inv_nghbr_head[bb];
-			inv_nghbr_head[bb] = aa;
-		}
-
-		// Reset the nearest neighbors of the inverse neighbors of the deletions.
-		for (int i = 0; i < tmp_size; i++) {
-			int aa = tmp[i];
-			int bb = qt_nearest_wrt(markers, qt, aa);
-			if (0 <= bb && bb < aa) {
-				n_nghbr[aa] = bb;
-				mindist[aa] = mr_distance(info, markers + aa, markers + bb);
-				pq_update(pq, aa);
-				inv_nghbr_next[aa] = inv_nghbr_head[bb];
-				inv_nghbr_head[bb] = aa;
-			} else {
-				pq_delete(pq, aa);
-			}
-		}
-	}
-	qt_clear(qt);
-	pq_clear(pq);
-	Free(n_nghbr);
-	Free(mindist);
-	Free(inv_nghbr_head);
-	Free(inv_nghbr_next);
-	Free(tmp);
-	return n_markers;
+    int augmented_length = 2 * n_markers - 1;
+    NewArrayDecl(int, n_nghbr, augmented_length);
+    NewArrayDecl(MARKER_DISTANCE, mindist, augmented_length);
+    NewArrayDecl(int, inv_nghbr_head, augmented_length);
+    NewArrayDecl(int, inv_nghbr_next, augmented_length);
+    NewArrayDecl(int, tmp, augmented_length); // Too big
+    // Do not free the following array!  It's owned by the priority queue.
+    NewArrayDecl(int, heap, augmented_length); // Too big
+
+    // Specialized quadtree supports finding closest marker to any given one.
+    QUADTREE_DECL(qt);
+
+    // Priority queue keyed on distances of overlapping pairs of markers.
+    PRIORITY_QUEUE_DECL(pq);
+
+    /// Extent of markers in the domain.
+    MARKER_EXTENT ext[1];
+
+    // Get a bounding box for the whole collection of markers.
+    get_marker_array_extent(markers, n_markers, ext);
+
+    // Set up the quadtree with the bounding box. Choose tree depth heuristically.
+    int max_depth = high_bit_position(n_markers) / 4 + 3;
+    qt_setup(qt, max_depth, ext->x, ext->y, ext->w, ext->h, info);
+
+    // Insert all the markers in the quadtree.
+    for (int i = 0; i < n_markers; i++)
+        qt_insert(qt, markers + i);
+
+    // Set all the inverse nearest neighbor links to null.
+    for (int i = 0; i < augmented_length; i++)
+        inv_nghbr_head[i] = inv_nghbr_next[i] = -1;
+
+    // Initialize the heap by adding an index for each overlapping pair. The
+    // The heap holds indices into the array of min-distance keys. An index for
+    // pair a->bis added iff markers with indices a and b overlap and b < a.
+    int heap_size = 0;
+    for (int a = 0; a < n_markers; a++) {
+        int b = qt_nearest_wrt(markers, qt, a);
+        if (0 <= b && b < a) {
+            n_nghbr[a] = b;
+            mindist[a] = mr_distance(info, markers + a, markers + b);
+            heap[heap_size++] = a;
+
+            // Here we are building a linked list of markers that have b as nearest.
+            inv_nghbr_next[a] = inv_nghbr_head[b];
+            inv_nghbr_head[b] = a;
+        }
+    }
+
+    // Now install the raw heap array into the priority queue. After this it's owned by the queue.
+    pq_set_up_heap(pq, heap, heap_size, mindist, augmented_length); // Too big
+
+    while (!pq_empty_p(pq)) {
+
+        // Get nearest pair from priority queue.
+        int a = pq_get_min(pq);
+        int b = n_nghbr[a];
+
+        // Delete both of the nearest pair from all data structures.
+        pq_delete(pq, b);
+        qt_delete(qt, markers + a);
+        qt_delete(qt, markers + b);
+        mr_set_deleted(markers + a);
+        mr_set_deleted(markers + b);
+
+        // Capture the inv lists of both a and b in tmp.
+        int tmp_size = 0;
+        for (int p = inv_nghbr_head[a]; p >= 0; p = inv_nghbr_next[p])
+            if (!markers[p].deleted_p)
+                tmp[tmp_size++] = p;
+        for (int p = inv_nghbr_head[b]; p >= 0; p = inv_nghbr_next[p])
+            if (!markers[p].deleted_p)
+                tmp[tmp_size++] = p;
+
+        // Create a new merged marker. Adding it after all others means
+        // nothing already in the heap could have it as nearest.
+        int aa = n_markers++;
+        mr_merge(info, markers, aa, a, b);
+
+        // Add to quadtree.
+        qt_insert(qt, markers + aa);
+
+        // Find nearest overlapping neighbor of the merged marker, if any.
+        int bb = qt_nearest_wrt(markers, qt, aa);
+        if (0 <= bb) {
+            n_nghbr[aa] = bb;
+            mindist[aa] = mr_distance(info, markers + aa, markers + bb);
+            pq_add(pq, aa);
+            inv_nghbr_next[aa] = inv_nghbr_head[bb];
+            inv_nghbr_head[bb] = aa;
+        }
+
+        // Reset the nearest neighbors of the inverse neighbors of the deletions.
+        for (int i = 0; i < tmp_size; i++) {
+            int aa = tmp[i];
+            int bb = qt_nearest_wrt(markers, qt, aa);
+            if (0 <= bb && bb < aa) {
+                n_nghbr[aa] = bb;
+                mindist[aa] = mr_distance(info, markers + aa, markers + bb);
+                pq_update(pq, aa);
+                inv_nghbr_next[aa] = inv_nghbr_head[bb];
+                inv_nghbr_head[bb] = aa;
+            } else {
+                pq_delete(pq, aa);
+            }
+        }
+    }
+    qt_clear(qt);
+    pq_clear(pq);
+    Free(n_nghbr);
+    Free(mindist);
+    Free(inv_nghbr_head);
+    Free(inv_nghbr_next);
+    Free(tmp);
+    return n_markers;
 }
-
-#ifndef EXCLUDE_UNIT_TEST
-
-#include <sys/time.h>
-
-/**
- * Generate many random markers and then merge them. Write
- * results as a Javascript array to be included included in a test page.
- */
-int merge_test(int size) {
-	struct timeval start[1], stop[1], diff[1];
-
-	MARKER_INFO_DECL(info);
-	mr_info_set(info, CIRCLE, 2);
-
-	NewArrayDecl(MARKER, markers, 2 * size - 1);
-	mr_init(markers, 2 * size - 1);
-	set_random_markers(info, markers, size);
-
-	int m = emit_markers("before", markers, size);
-	fprintf(stderr, "before merge: %d\nmerging...\n", m);
-
-	gettimeofday(start, NULL);
-
-	size = merge_markers_fast(info, markers, size);
-
-	gettimeofday(stop, NULL);
-
-	int n = emit_markers("after", markers, size);
-	fprintf(stderr, "after merge: %d\n", n);
-
-	timersub(stop, start, diff);
-	fprintf(stderr, "%.3f seconds", diff->tv_sec + 1.0e-6 * diff->tv_usec);
-
-	return EXIT_SUCCESS;
-}
-
-#endif