lulu 0.0.2 → 0.0.3

data/ext/lulu/qt.h

@@ -11,9 +11,9 @@
 #include "marker.h"
 
 typedef struct node_s {
-	struct node_s *children;
-	MARKER **markers;
-	int marker_count, markers_size;
+    struct node_s *children;
+    MARKER **markers;
+    int marker_count, markers_size;
 } NODE;
 
 #define leaf_p(Node) ((Node)->children == NULL)
@@ -37,21 +37,22 @@ typedef struct node_s {
 #define NE 3
 
 typedef struct quadtree_s {
-	double x, y, w, h;
-	int max_depth;
-	MARKER_INFO *info;
-	NODE root[1];
+    MARKER_COORD x, y;
+    MARKER_DISTANCE w, h;
+    int max_depth;
+    MARKER_INFO *info;
+    NODE root[1];
 } QUADTREE;
 
 #define QUADTREE_DECL(Name) QUADTREE Name[1]; qt_init(Name)
 
 void qt_init(QUADTREE *qt);
-void qt_setup(QUADTREE *qt, int max_depth, double x, double y, double w, double h, MARKER_INFO *info);
+void qt_setup(QUADTREE *qt, int max_depth,
+        MARKER_COORD x, MARKER_COORD y, MARKER_DISTANCE w, MARKER_DISTANCE h,
+        MARKER_INFO *info);
 void qt_insert(QUADTREE *qt, MARKER *marker);
 void qt_delete(QUADTREE *qt, MARKER *marker);
 MARKER *qt_nearest(QUADTREE *qt, MARKER *marker);
 int qt_nearest_wrt(MARKER *markers, QUADTREE *qt, int a);
-void qt_clear(QUADTREE *qt);
-int qt_test(int size);
 
 #endif /* QT_H_ */

data/ext/lulu/test.c

@@ -5,78 +5,254 @@
  *      Author: generessler
  */
 
+#ifdef UNIT_TESTS
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <time.h>
+#include <sys/time.h>
 #include "test.h"
 #include "utility.h"
 
+double rand_double(void)
+{
+    unsigned i = rand();
+    i = (i << 8) ^ (unsigned)rand();
+    i = (i << 8) ^ (unsigned)rand();
+    i = (i << 8) ^ (unsigned)rand();
+    return i / (256.0 * 256.0 * 256.0 * 256.0);
+}
+
 void emit_rectangle(FILE *f, double x, double y, double w, double h) {
-	fprintf(f, "  { kind: 'r', color: 'lightGray', p0: { x: %.2f, y: %.2f }, p1: { x: %.2f, y: %.2f } },\n", x, y, x + w, y + h);
+    fprintf(f, "  { kind: 'r', color: 'lightGray', p0: { x: %.2f, y: %.2f }, p1: { x: %.2f, y: %.2f } },\n", x, y, x + w, y + h);
 }
 
 void emit_segment(FILE *f, MARKER *a, MARKER *b) {
-	fprintf(f, "  { kind: 's', color: 'red', p0: { x: %.2f, y: %.2f }, p1: { x: %.2f, y: %.2f } },\n",
-			mr_x(a), mr_y(a), mr_x(b), mr_y(b));
+    fprintf(f, "  { kind: 's', color: 'red', p0: { x: %.2f, y: %.2f }, p1: { x: %.2f, y: %.2f } },\n",
+            mr_x(a), mr_y(a), mr_x(b), mr_y(b));
 }
 
 int emit_marker_ptr_array(FILE *f, MARKER **markers, int n_markers) {
-	int n_emitted = 0;
-	for (int i = 0; i < n_markers; ++i) {
-		MARKER *m = markers[i];
-		if (!m->deleted_p) {
-			fprintf(f, "  { kind: 'm', x: %.2f, y: %.2f, r: %.2f }, // %d\n", mr_x(m), mr_y(m), mr_r(m), i);
-			n_emitted++;
-		}
-	}
-	return n_emitted;
+    int n_emitted = 0;
+    for (int i = 0; i < n_markers; ++i) {
+        MARKER *m = markers[i];
+        if (!m->deleted_p) {
+            fprintf(f, "  { kind: 'm', x: %.2f, y: %.2f, r: %.2f }, // %d\n", mr_x(m), mr_y(m), mr_r(m), i);
+            n_emitted++;
+        }
+    }
+    return n_emitted;
 }
 
 int emit_marker_array(FILE *f, MARKER *markers, int n_markers) {
-	int n_emitted = 0;
-	for (int i = 0; i < n_markers; ++i) {
-		MARKER *m = markers + i;
-		if (!m->deleted_p) {
-			fprintf(f, "  { x: %.2f, y: %.2f, r: %.2f }, // %d\n", mr_x(m), mr_y(m), mr_r(m), i);
-			n_emitted++;
-		}
-	}
-	return n_emitted;
+    int n_emitted = 0;
+    for (int i = 0; i < n_markers; ++i) {
+        MARKER *m = markers + i;
+        if (!m->deleted_p) {
+            fprintf(f, "  { x: %.2f, y: %.2f, r: %.2f }, // %d\n", mr_x(m), mr_y(m), mr_r(m), i);
+            n_emitted++;
+        }
+    }
+    return n_emitted;
 }
 
 int emit_markers(const char *name, MARKER *markers, int n_markers) {
-	char buf[1024];
-	sprintf(buf, "test/%s.js", name);
-	FILE *f = fopen(buf, "w");
-	if (!f)
-		return -1;
-	fprintf(f, "var %s = [\n", name);
-	int n_emitted = emit_marker_array(f, markers, n_markers);
-	fprintf(f, "];");
-	fclose(f);
-	return n_emitted;
+    char buf[1024];
+    sprintf(buf, "test/%s.js", name);
+    FILE *f = fopen(buf, "w");
+    if (!f)
+        return -1;
+    fprintf(f, "var %s = [\n", name);
+    int n_emitted = emit_marker_array(f, markers, n_markers);
+    fprintf(f, "];");
+    fclose(f);
+    return n_emitted;
 }
 
 void set_random_markers(MARKER_INFO *info, MARKER *markers, int n_markers) {
-	unsigned t = (unsigned)time(0);
-	fprintf(stderr, "seed=%u\n", t);
-	srand(t);
-	int size = 8;
-	double x_size = 1024;
-	double y_size = 760;
-	for (int i = 0; i < n_markers; i++)
-		mr_set(info, markers + i, x_size * rand_double(), y_size * rand_double(), 1 + random() % (size - 1));
+    unsigned t = (unsigned)time(0);
+    fprintf(stderr, "seed=%u\n", t);
+    srand(t);
+    int size = 8;
+    double x_size = 1024;
+    double y_size = 760;
+    for (int i = 0; i < n_markers; i++)
+        mr_set(info, markers + i, x_size * rand_double(), y_size * rand_double(), 1 + random() % (size - 1));
 }
 
 int trace_p = 1;
 
 void trace(const char *fmt, ...)
 {
-	if (trace_p) {
-		va_list ap;
-		va_start(ap, fmt);
-		vfprintf(stderr, fmt, ap);
-		va_end(ap);
-	}
+    if (trace_p) {
+        va_list ap;
+        va_start(ap, fmt);
+        vfprintf(stderr, fmt, ap);
+        va_end(ap);
+    }
+}
+
+/**
+ * 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;
+}
+
+
+/* Randomly permute the given distance array. */
+void permute(PRIORITY_QUEUE_VALUE *a, int size) {
+    for (int i = size - 1; i > 0; i--) {
+        int j = rand() % (i + 1);
+        PRIORITY_QUEUE_VALUE tmp = a[i];
+        a[i] = a[j];
+        a[j] = tmp;
+    }
+}
+
+// Run a unit test on a priority queue of random data with given size.
+int pq_test(int size) {
+    PRIORITY_QUEUE q[1];
+    pq_init(q);
+
+    fprintf(stderr, "test: heap_ops (n = %d):\n", size);
+
+    // Build linear pointer array of random keys.
+    PRIORITY_QUEUE_VALUE *dist;
+    NewArray(dist, size);
+    for (int i = 0; i < size; i++)
+        dist[i] = i;
+    permute(dist, size);
+    fprintf(stderr, "  built random data\n");
+
+    pq_set_up(q, dist, size);
+    fprintf(stderr, "  finished set up\n");
+
+    // Pull min repeatedly and verify vals are what they should be.
+    PRIORITY_QUEUE_VALUE should_be = 0;
+    for (int n = 0; n < size; n++) {
+        int i = pq_get_min(q);
+        if (dist[i] != should_be++) {
+            fprintf(stderr, "fail 1: %i -> %g\n", i, dist[i]);
+            return 42;
+        }
+    }
+    fprintf(stderr, "  finished checking heapify\n");
+
+    // Now rebuild the heap by inserting one key at a time.
+    for (int n = 0; n < size; n++)
+        pq_add(q, n);
+    fprintf(stderr, "  finished insertions\n");
+
+    // And verify values again.
+    should_be = 0;
+    for (int n = 0; n < size; n++) {
+        int i = pq_get_min(q);
+        if (dist[i] != should_be++) {
+            fprintf(stderr, "  fail 2: %i -> %g\n", i, dist[i]);
+            return 4242;
+        }
+    }
+    fprintf(stderr, "  finished checking insert\n");
+
+    // Now rebuild the heap by inserting one key at a time in reverse.
+    for (int n = size - 1; n >= 0; n--)
+        pq_add(q, n);
+    fprintf(stderr, "  finished reverse insertions\n");
+
+    // Now delete one by one.
+    for (int n = 0; n < size; n++)
+        pq_delete(q, n);
+    fprintf(stderr, "  finished reverse deletions\n");
+
+    pq_clear(q);
+    return 0;
 }
+
+static void draw(FILE *f, NODE *node, double x, double y, double w, double h) {
+    emit_rectangle(f, x, y, w, h);
+    emit_marker_ptr_array(f, node->markers, node->marker_count);
+    if (internal_p(node)) {
+        for (int q = 0; q < 4; q++) {
+            QUADRANT_DECL(q, qx, qy, qw, qh, x, y, w, h);
+            draw(f, node->children + q, qx, qy, qw, qh);
+        }
+    }
+}
+
+static void draw_nearest(FILE *f, MARKER *markers, MARKER **nearest_markers, int n_markers) {
+    for (int i = 0; i < n_markers; i++) {
+        if (nearest_markers[i])
+            emit_segment(f, markers + i, nearest_markers[i]);
+    }
+}
+
+int qt_draw(QUADTREE *qt, MARKER *markers, MARKER **nearest_markers, int n_markers, const char *name) {
+    char buf[1024];
+    sprintf(buf, "test/%s.js", name);
+    FILE *f = fopen(buf, "w");
+    if (!f)
+        return -1;
+    fprintf(f, "var %s = [\n", name);
+    draw(f, qt->root, qt->x, qt->y, qt->w, qt->h);
+    draw_nearest(f, markers, nearest_markers, n_markers);
+    fprintf(f, "];\n");
+    fclose(f);
+    return EXIT_SUCCESS;
+}
+
+int qt_test(int size) {
+    QUADTREE_DECL(qt);
+    MARKER_INFO_DECL(info);
+    MARKER *markers, **nearest_markers;
+    NewArray(markers, size);
+    NewArray(nearest_markers, size);
+    set_random_markers(info, markers, size);
+    qt_setup(qt, 5, 0, 0, 1024, 724, info);
+    fprintf(stderr, "inserting %d:\n", size);
+    for (int i = 0; i < size; i++) {
+        qt_insert(qt, markers + i);
+    }
+    fprintf(stderr, "inserted %d\n", size);
+    for (int i = 0; i < size; i++) {
+        nearest_markers[i] = qt_nearest(qt, markers + i);
+    }
+    fprintf(stderr, "looked up %d\n", size);
+    qt_draw(qt, markers, nearest_markers, size, "qt");
+    fprintf(stderr, "drew %d\n", size);
+    for (int i = 0; i < size; i++) {
+        qt_delete(qt, markers + i);
+    }
+    fprintf(stderr, "after delete all, root is %s\n",
+            leaf_p(qt->root) ? "leaf (ok)" : "internal (not ok)");
+
+    return EXIT_SUCCESS;
+}
+
+#endif

data/ext/lulu/test.h

@@ -15,6 +15,11 @@ void emit_rectangle(FILE *f, double x, double y, double w, double h);
 void emit_segment(FILE *f, MARKER *a, MARKER *b);
 int emit_marker_array(FILE *f, MARKER *markers, int n_markers);
 int emit_marker_ptr_array(FILE *f, MARKER **markers, int n_markers);
+double rand_double(void);
 void set_random_markers(MARKER_INFO *info, MARKER *markers, int n_markers);
+void qt_clear(QUADTREE *qt);
+int qt_test(int size);
+int pq_test(int size);
+int merge_test(int test_markers_size);
 
 #endif /* TEST_H_ */

data/ext/lulu/utility.c

@@ -9,41 +9,37 @@
 #include <stdlib.h>
 #include "utility.h"
 
+#ifdef LULU_STD_C
+
 void *safe_malloc(size_t size, const char *file, int line) {
-	void *p = malloc(size);
-	if (!p) {
-		fprintf(stderr, "%s:%d: out of memory\n", file, line);
-		exit(1);
-	}
-	return p;
+    void *p = malloc(size);
+    if (!p) {
+        fprintf(stderr, "%s:%d: out of memory\n", file, line);
+        exit(1);
+    }
+    return p;
 }
 
 void *safe_realloc(void *p, size_t size, const char *file, int line) {
-	p = realloc(p, size);
-	if (!p) {
-		fprintf(stderr, "%s:%d: out of memory\n", file, line);
-		exit(1);
-	}
-	return p;
+    p = realloc(p, size);
+    if (!p) {
+        fprintf(stderr, "%s:%d: out of memory\n", file, line);
+        exit(1);
+    }
+    return p;
 }
 
+#endif
+
 /**
  * Return the 0-based position of highest bit or -1 of zero.
  */
 int high_bit_position(unsigned n) {
-	int p = -1;
-	while (n) {
-		p++;
-		n >>= 1;
-	}
-	return p;
+    int p = -1;
+    while (n) {
+        p++;
+        n >>= 1;
+    }
+    return p;
 }
 
-double rand_double(void)
-{
-	unsigned i = rand();
-	i = (i << 8) ^ (unsigned)rand();
-	i = (i << 8) ^ (unsigned)rand();
-	i = (i << 8) ^ (unsigned)rand();
-	return i / (256.0 * 256.0 * 256.0 * 256.0);
-}

data/ext/lulu/utility.h

@@ -10,45 +10,51 @@
 
 #define STATIC_ARRAY_SIZE(A) ((int)(sizeof A / sizeof A[0]))
 
-#ifdef NOT_RUBY_EXTENSION
+#ifdef LULU_STD_C
 
 // Our allocators.
 #define New(Ptr) do { \
-	(Ptr) = safe_malloc(sizeof *(Ptr), __FILE__, __LINE__); \
+    (Ptr) = safe_malloc(sizeof *(Ptr), __FILE__, __LINE__); \
 } while (0)
 
 #define NewArray(Ptr, Size) do { \
-	(Ptr) = safe_malloc((Size) * sizeof *(Ptr), __FILE__, __LINE__); \
+    (Ptr) = safe_malloc((Size) * sizeof *(Ptr), __FILE__, __LINE__); \
 } while (0)
 
 #define RenewArray(Ptr, Size) do { \
-	(Ptr) = safe_realloc((Ptr), (Size) * sizeof *(Ptr), __FILE__, __LINE__); \
+    (Ptr) = safe_realloc((Ptr), (Size) * sizeof *(Ptr), __FILE__, __LINE__); \
 } while (0)
 
 #define Free(Ptr) do { \
-	free(Ptr); \
-	Ptr = NULL; \
+    free(Ptr); \
+    Ptr = NULL; \
 } while (0)
 
-#else
+void *safe_malloc(size_t size, const char *file, int line);
+void *safe_realloc(void *p, size_t size, const char *file, int line);
+
+#endif
+
+#ifdef LULU_GEM
 
 #include "ruby.h"
 
 // Ruby allocators.  We can't use the macros without rewriting to include type parameters.
 #define New(Ptr) do { \
-	(Ptr) = (void*)xmalloc(sizeof *(Ptr)); \
+    (Ptr) = (void*)xmalloc(sizeof *(Ptr)); \
 } while (0)
 
 #define NewArray(Ptr, Size) do { \
-	(Ptr) = (void*)xmalloc2((Size), sizeof *(Ptr)); \
+    (Ptr) = (void*)xmalloc2((Size), sizeof *(Ptr)); \
 } while (0)
 
 #define RenewArray(Ptr, Size) do { \
-	(Ptr) = (void*)xrealloc2((char*)(Ptr), (Size), sizeof *(Ptr)); \
+    (Ptr) = (void*)xrealloc2((char*)(Ptr), (Size), sizeof *(Ptr)); \
 } while (0)
 
 #define Free(Ptr) do { \
-	Ptr = NULL; \
+    xfree(Ptr); \
+    Ptr = NULL; \
 } while (0)
 
 #endif
@@ -66,9 +72,6 @@ void trace(const char *fmt, ...);
 #define TRACE(Args)
 #endif
 
-void *safe_malloc(size_t size, const char *file, int line);
-void *safe_realloc(void *p, size_t size, const char *file, int line);
 int high_bit_position(unsigned n);
-double rand_double(void);
 
 #endif /* UTILITY_H_ */