rubyvor 0.1.3

data/ext/geometry.c

@@ -0,0 +1,219 @@
+
+/*** GEOMETRY.C ***/
+
+#include <math.h>
+#include "vdefs.h"
+
+static Freelist efl;
+
+void
+geominit(void)
+{
+    freeinit(&efl, sizeof(Edge)) ;
+    rubyvorState.nvertices = rubyvorState.nedges = 0 ;
+    rubyvorState.sqrt_nsites = sqrt(rubyvorState.nsites+4) ;
+    rubyvorState.deltay = rubyvorState.ymax - rubyvorState.ymin ;
+    rubyvorState.deltax = rubyvorState.xmax - rubyvorState.xmin ;
+}
+
+Edge *
+bisect(Site * s1, Site * s2)
+{
+    float dx, dy, adx, ady ;
+    Edge * newedge ;
+
+    newedge = (Edge *)getfree(&efl) ;
+    newedge->reg[0] = s1 ;
+    newedge->reg[1] = s2 ;
+    ref(s1) ;
+    ref(s2) ;
+    newedge->ep[0] = newedge->ep[1] = (Site *)NULL ;
+    dx = s2->coord.x - s1->coord.x ;
+    dy = s2->coord.y - s1->coord.y ;
+    adx = dx>0 ? dx : -dx ;
+    ady = dy>0 ? dy : -dy ;
+    newedge->c = s1->coord.x * dx + s1->coord.y * dy + (dx*dx +
+dy*dy) * 0.5 ;
+    if (adx > ady)
+    {
+        newedge->a = 1.0 ;
+        newedge->b = dy/dx ;
+        newedge->c /= dx ;
+    }
+    else
+    {
+        newedge->b = 1.0 ;
+        newedge->a = dx/dy ;
+        newedge->c /= dy ;
+    }
+    newedge->edgenbr = rubyvorState.nedges ;
+    out_bisector(newedge) ;
+    rubyvorState.nedges++ ;
+    return (newedge) ;
+}
+
+Site *
+intersect(Halfedge * el1, Halfedge * el2)
+{
+    Edge * e1, * e2, * e ;
+    Halfedge * el ;
+    float d, xint, yint ;
+    int right_of_site ;
+    Site * v ;
+
+    e1 = el1->ELedge ;
+    e2 = el2->ELedge ;
+    if ((e1 == (Edge*)NULL) || (e2 == (Edge*)NULL))
+    {
+        return ((Site *)NULL) ;
+    }
+    if (e1->reg[1] == e2->reg[1])
+    {
+        return ((Site *)NULL) ;
+    }
+    d = (e1->a * e2->b) - (e1->b * e2->a) ;
+    if ((-1.0e-10 < d) && (d < 1.0e-10))
+    {
+        return ((Site *)NULL) ;
+    }
+    xint = (e1->c * e2->b - e2->c * e1->b) / d ;
+    yint = (e2->c * e1->a - e1->c * e2->a) / d ;
+    if ((e1->reg[1]->coord.y < e2->reg[1]->coord.y) ||
+        (e1->reg[1]->coord.y == e2->reg[1]->coord.y &&
+        e1->reg[1]->coord.x < e2->reg[1]->coord.x))
+    {
+        el = el1 ;
+        e = e1 ;
+    }
+    else
+    {
+        el = el2 ;
+        e = e2 ;
+    }
+    right_of_site = (xint >= e->reg[1]->coord.x) ;
+    if ((right_of_site && (el->ELpm == le)) ||
+       (!right_of_site && (el->ELpm == re)))
+    {
+        return ((Site *)NULL) ;
+    }
+    v = (Site *)getfree(&(rubyvorState.sfl)) ;
+    v->refcnt = 0 ;
+    v->coord.x = xint ;
+    v->coord.y = yint ;
+    return (v) ;
+}
+
+/*** returns 1 if p is to right of halfedge e ***/
+
+int
+right_of(Halfedge * el, Point * p)
+{
+    Edge * e ;
+    Site * topsite ;
+    int right_of_site, above, fast ;
+    float dxp, dyp, dxs, t1, t2, t3, yl ;
+
+    e = el->ELedge ;
+    topsite = e->reg[1] ;
+    right_of_site = (p->x > topsite->coord.x) ;
+    if (right_of_site && (el->ELpm == le))
+    {
+        return (1) ;
+    }
+    if(!right_of_site && (el->ELpm == re))
+    {
+        return (0) ;
+    }
+    if (e->a == 1.0)
+    {
+        dyp = p->y - topsite->coord.y ;
+        dxp = p->x - topsite->coord.x ;
+        fast = 0 ;
+        if ((!right_of_site & (e->b < 0.0)) ||
+         (right_of_site & (e->b >= 0.0)))
+        {
+            fast = above = (dyp >= e->b*dxp) ;
+        }
+        else
+        {
+            above = ((p->x + p->y * e->b) > (e->c)) ;
+            if (e->b < 0.0)
+            {
+                above = !above ;
+            }
+            if (!above)
+            {
+                fast = 1 ;
+            }
+        }
+        if (!fast)
+        {
+            dxs = topsite->coord.x - (e->reg[0])->coord.x ;
+            above = (e->b * (dxp*dxp - dyp*dyp))
+                    <
+                    (dxs * dyp * (1.0 + 2.0 * dxp /
+                    dxs + e->b * e->b)) ;
+            if (e->b < 0.0)
+            {
+                above = !above ;
+            }
+        }
+    }
+    else  /*** e->b == 1.0 ***/
+    {
+        yl = e->c - e->a * p->x ;
+        t1 = p->y - yl ;
+        t2 = p->x - topsite->coord.x ;
+        t3 = yl - topsite->coord.y ;
+        above = ((t1*t1) > ((t2 * t2) + (t3 * t3))) ;
+    }
+    return (el->ELpm == le ? above : !above) ;
+}
+
+void
+endpoint(Edge * e, int lr, Site * s)
+{
+    e->ep[lr] = s ;
+    ref(s) ;
+    if (e->ep[re-lr] == (Site *)NULL)
+    {
+        return ;
+    }
+    out_ep(e) ;
+    deref(e->reg[le]) ;
+    deref(e->reg[re]) ;
+    makefree((Freenode *)e, (Freelist *) &efl) ;
+}
+
+float
+dist(Site * s, Site * t)
+{
+    float dx,dy ;
+
+    dx = s->coord.x - t->coord.x ;
+    dy = s->coord.y - t->coord.y ;
+    return (sqrt(dx*dx + dy*dy)) ;
+}
+
+void
+makevertex(Site * v)
+{
+    v->sitenbr = rubyvorState.nvertices++ ;
+    out_vertex(v) ;
+}
+
+void
+deref(Site * v)
+{
+    if (--(v->refcnt) == 0 )
+    {
+        makefree((Freenode *)v, (Freelist *)&(rubyvorState.sfl)) ;
+    }
+}
+
+void
+ref(Site * v)
+{
+    ++(v->refcnt) ;
+}
+

data/ext/heap.c

@@ -0,0 +1,118 @@
+
+/*** HEAP.C ***/
+
+
+#include "vdefs.h"
+
+static int PQmin, PQcount, PQhashsize ;
+static Halfedge * PQhash ;
+
+void
+PQinsert(Halfedge * he, Site * v, float offset)
+{
+    Halfedge * last, * next ;
+
+    he->vertex = v ;
+    ref(v) ;
+    he->ystar = v->coord.y + offset ;
+    last = &PQhash[ PQbucket(he)] ;
+    while ((next = last->PQnext) != (Halfedge *)NULL &&
+           (he->ystar  > next->ystar  ||
+            (he->ystar == next->ystar &&
+             v->coord.x > next->vertex->coord.x)))
+    {
+        last = next ;
+    }
+    he->PQnext = last->PQnext ;
+    last->PQnext = he ;
+    PQcount++ ;
+}
+
+void
+PQdelete(Halfedge * he)
+{
+    Halfedge * last;
+
+    if(he ->  vertex != (Site *) NULL)
+    {
+        last = &PQhash[PQbucket(he)] ;
+        while (last -> PQnext != he)
+        {
+            last = last->PQnext ;
+        }
+        last->PQnext = he->PQnext;
+        PQcount-- ;
+        deref(he->vertex) ;
+        he->vertex = (Site *)NULL ;
+    }
+}
+
+int
+PQbucket(Halfedge * he)
+{
+    int bucket ;
+
+
+    if	    (he->ystar < rubyvorState.ymin)  bucket = 0;
+    else if (he->ystar >= rubyvorState.ymax) bucket = PQhashsize-1;
+    else 			bucket = (he->ystar - rubyvorState.ymin)/rubyvorState.deltay * PQhashsize;
+    if (bucket < 0)
+    {
+        bucket = 0 ;
+    }
+    if (bucket >= PQhashsize)
+    {
+        bucket = PQhashsize-1 ;
+    }
+    if (bucket < PQmin)
+    {
+        PQmin = bucket ;
+    }
+    return (bucket);
+}
+
+int
+PQempty(void)
+{
+    return (PQcount == 0) ;
+}
+
+
+Point
+PQ_min(void)
+{
+    Point answer ;
+
+    while (PQhash[PQmin].PQnext == (Halfedge *)NULL)
+    {
+        ++PQmin ;
+    }
+    answer.x = PQhash[PQmin].PQnext->vertex->coord.x ;
+    answer.y = PQhash[PQmin].PQnext->ystar ;
+    return (answer) ;
+}
+
+Halfedge *
+PQextractmin(void)
+{
+    Halfedge * curr ;
+
+    curr = PQhash[PQmin].PQnext ;
+    PQhash[PQmin].PQnext = curr->PQnext ;
+    PQcount-- ;
+    return (curr) ;
+}
+
+void
+PQinitialize(void)
+{
+    int i ;
+
+    PQcount = PQmin = 0 ;
+    PQhashsize = 4 * rubyvorState.sqrt_nsites ;
+    PQhash = (Halfedge *)myalloc(PQhashsize * sizeof *PQhash) ;
+    for (i = 0 ; i < PQhashsize; i++)
+    {
+        PQhash[i].PQnext = (Halfedge *)NULL ;
+    }
+}

data/ext/memory.c

@@ -0,0 +1,118 @@
+
+/*** MEMORY.C ***/
+
+#include <ruby.h>
+#include <stdio.h>
+#include <stdlib.h>  /* malloc() */
+
+#include "vdefs.h"
+
+static char** memory_map;
+static int nallocs = 0;
+
+void
+freeinit(Freelist * fl, int size)
+{
+    fl->head = (Freenode *)NULL ;
+    fl->nodesize = size ;
+}
+
+char *
+getfree(Freelist * fl)
+{
+    int i ;
+    Freenode * t ;
+    if (fl->head == (Freenode *)NULL)
+    {
+        t =  (Freenode *) myalloc(rubyvorState.sqrt_nsites * fl->nodesize) ;
+        for(i = 0 ; i < rubyvorState.sqrt_nsites ; i++)
+        {
+            makefree((Freenode *)((char *)t+i*fl->nodesize), fl) ;
+        }
+    }
+    t = fl->head ;
+    fl->head = (fl->head)->nextfree ;
+    return ((char *)t) ;
+}
+
+void
+makefree(Freenode * curr, Freelist * fl)
+{
+    curr->nextfree = fl->head ;
+    fl->head = curr ;
+}
+
+int total_alloc;
+
+void
+update_memory_map(char * newp)
+{
+    if (nallocs % 1000 == 0)
+	{
+		if (nallocs == 0)
+			memory_map = (char **)malloc((nallocs+1000)*sizeof(char*));
+		else
+			memory_map = (char **)realloc(memory_map,(nallocs+1000)*sizeof(char*));
+	}
+	memory_map[nallocs++] = newp;
+}
+
+char *
+myalloc(unsigned n)
+{
+    char * t;
+    
+    if ((t=(char*)malloc(n)) == (char *) 0)
+        rb_raise(rb_eNoMemError, "Insufficient memory processing site %d (%d bytes in use)\n", rubyvorState.siteidx, total_alloc);
+
+    total_alloc += n;
+    
+    update_memory_map(t);
+    return (t);
+}
+
+char *
+myrealloc(void * oldp, unsigned n, unsigned oldn)
+{
+    char * newp;
+    int i;
+    
+    if ((newp=(char*)realloc(oldp, n)) == (char *) 0)
+        rb_raise(rb_eNoMemError, "Insufficient memory processing site %d (%d bytes in use)\n", rubyvorState.siteidx, total_alloc);
+
+    total_alloc += (n - oldn);
+
+    update_memory_map(newp);
+
+    /*
+     * Mark oldp as freed, since free() was called by realloc.
+     *
+     * TODO: this seems naive; measure if this is a bottleneck & use a hash table or some other scheme if it is.
+     */
+    for (i=0; i<nallocs; i++)
+    {
+        if (memory_map[i] != (char*)0 && memory_map[i] == oldp)
+        {
+            memory_map[i] = (char*)0;
+            break;
+        }
+    }
+    
+    return (newp);
+}
+    
+
+void free_all(void)
+{
+	int i;
+	for (i=0; i<nallocs; i++)
+	{
+		if (memory_map[i] != (char*)0)
+		{
+			free(memory_map[i]);
+			memory_map[i] = (char*)0;
+		}
+	}
+	free(memory_map);
+	nallocs = 0;
+}