miniball_ruby 0.0.2

data/ext/miniball_ruby/Makefile

@@ -0,0 +1,157 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/lib/ruby/1.8/i686-linux
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+exec_prefix = $(prefix)
+prefix = $(DESTDIR)/usr
+sharedstatedir = $(prefix)/com
+mandir = $(prefix)/share/man
+psdir = $(docdir)
+oldincludedir = $(DESTDIR)/usr/include
+localedir = $(datarootdir)/locale
+bindir = $(exec_prefix)/bin
+libexecdir = $(prefix)/lib/ruby1.8
+sitedir = $(DESTDIR)/usr/local/lib/site_ruby
+htmldir = $(docdir)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+includedir = $(prefix)/include
+infodir = $(prefix)/share/info
+vendorlibdir = $(vendordir)/$(ruby_version)
+sysconfdir = $(DESTDIR)/etc
+libdir = $(exec_prefix)/lib
+sbindir = $(exec_prefix)/sbin
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+vendordir = $(libdir)/ruby/vendor_ruby
+datarootdir = $(prefix)/share
+pdfdir = $(docdir)
+archdir = $(rubylibdir)/$(arch)
+sitearchdir = $(sitelibdir)/$(sitearch)
+datadir = $(datarootdir)
+localstatedir = $(DESTDIR)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fPIC -fno-strict-aliasing -g -g -O2  -fPIC $(cflags) 
+INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
+DEFS     = -D_FILE_OFFSET_BITS=64
+CPPFLAGS =   $(DEFS) $(cppflags)
+CXXFLAGS = $(CFLAGS) 
+ldflags  = -L. -Wl,-Bsymbolic-functions -rdynamic -Wl,-export-dynamic
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = $(CC) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby1.8
+RUBY_SO_NAME = ruby1.8
+arch = i686-linux
+sitearch = i686-linux
+ruby_version = 1.8
+ruby = /usr/bin/ruby1.8
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = /miniball_ruby
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -lrt -ldl -lcrypt -lm   -lc
+SRCS = util.c miniball_builder_dynamic_d.c point_dynamic_d.c miniball_dynamic_d.c miniball_ruby.c
+OBJS = util.o miniball_builder_dynamic_d.o point_dynamic_d.o miniball_dynamic_d.o miniball_ruby.o
+TARGET = miniball_ruby
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/miniball_ruby/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+#TODO: Try to include the non-dynamic versions for 2 and 3 dimensions
+#TODO: Switch to ffi? Also check out ffi-inliner
+create_makefile 'miniball_ruby/miniball_ruby'

data/ext/miniball_ruby/miniball_builder_dynamic_d.c

@@ -0,0 +1,188 @@
+#include <stdlib.h>
+#include "util.h"
+#include "point_dynamic_d.h"
+#include "miniball_builder_dynamic_d.h"
+
+MiniballBuilder* MiniballBuilder_create(int dim) {
+  int size = sizeof(double) * (dim+1);
+  int innerSize = sizeof(double) * dim;
+
+  MiniballBuilder* mb = malloc(sizeof(MiniballBuilder));
+
+  mb->d = dim;
+
+  mb->q0    = malloc(size);
+  mb->z     = malloc(size);
+  mb->f     = malloc(size);
+  mb->sqr_r = malloc(size);
+
+  mb->v = malloc(size);
+  mb->a = malloc(size);
+  mb->c = malloc(size);
+
+  int i;
+  for(i = 0; i < dim + 1; ++i) {
+    mb->v[i] = malloc(innerSize);
+    mb->a[i] = malloc(innerSize);
+    mb->c[i] = malloc(innerSize);
+  }
+
+  MiniballBuilder_reset(mb);
+
+  return mb;
+}
+
+void MiniballBuilder_destroy(MiniballBuilder* mb) {
+  int i;
+  for(i = 0; i < mb->d + 1; ++i) {
+    free(mb->v[i]);
+    free(mb->a[i]);
+    free(mb->c[i]);
+  }
+
+  free(mb->v);
+  free(mb->a);
+  free(mb->c);
+
+  free(mb->q0);
+  free(mb->z);
+  free(mb->f);
+  free(mb->sqr_r);
+
+  free(mb);
+}
+
+const double* MiniballBuilder_center(MiniballBuilder* mb) {
+  return mb->current_c;
+}
+
+double MiniballBuilder_squared_radius(MiniballBuilder* mb) {
+  return mb->current_sqr_r;
+}
+
+int MiniballBuilder_size(MiniballBuilder* mb) {
+  return mb->m;
+}
+
+int MiniballBuilder_support_size(MiniballBuilder* mb) {
+  return mb->s;
+}
+
+double MiniballBuilder_excess(MiniballBuilder* mb, const Point* p) {
+  double e = -mb->current_sqr_r;
+  int i;
+  for(i = 0; i < mb->d; ++i) {
+    e += sqr(p->coord[i] - mb->current_c[i]);
+  }
+  return e;
+}
+
+void MiniballBuilder_reset(MiniballBuilder* mb) {
+  mb->m = mb->s = 0;
+  int i;
+  for(i = 0; i < mb->d; ++i) {
+    mb->c[0][i] = 0;
+  }
+  mb->current_c = mb->c[0];
+  mb->current_sqr_r = -1;
+}
+
+//TODO: Document
+int MiniballBuilder_push(MiniballBuilder* mb, Point* p) {
+  int supPoint = mb->m;
+  int dim = mb->d;
+
+  int i, j;
+  double eps = 1e-32;
+  if(supPoint == 0) {
+    for(i = 0; i < dim; ++i) {
+      double c = p->coord[i];
+      mb->q0[i] = c;
+      mb->c[0][i] = c;
+    }
+    mb->sqr_r[0] = 0;
+  } else {
+    for(i = 0; i < dim; ++i) {
+      //Set v_m to Q_m
+      mb->v[supPoint][i] = p->coord[i] - mb->q0[i];
+    }
+
+    //Compute the a_{supPoint,i}, i < supPoint
+    for(i = 1; i < supPoint; ++i) {
+      double* a = mb->a[supPoint];
+      a[i] = 0;
+      for(j = 0; j < dim; ++j) {
+        a[i] += mb->v[i][j] * mb->v[supPoint][j];
+      }
+      a[i] *= (2 / mb->z[i]);
+    }
+
+    //Update v_m to Q_m - \bar{Q}_m
+    for(i = 1; i < supPoint; ++i) {
+      for(j = 0; j < dim; ++j) {
+        mb->v[supPoint][j] -= mb->a[supPoint][i] * mb->v[i][j];
+      }
+    }
+
+    //compute z_m
+    mb->z[supPoint] = 0;
+    for(j = 0; j < dim; ++j) {
+      mb->z[supPoint] += sqr(mb->v[supPoint][j]);
+    }
+    mb->z[supPoint] *= 2;
+
+    //Reject push if z_m too small
+    if(mb->z[supPoint] < eps * mb->current_sqr_r) {
+      return 0;
+    }
+
+    //Update c, sqr_c
+    double e = -mb->sqr_r[supPoint - 1];
+    for(i = 0; i < dim; ++i) {
+      e += sqr(p->coord[i] - mb->c[supPoint - 1][i]);
+    }
+    double f = e / mb->z[supPoint];
+    mb->f[supPoint] = f;
+
+    for(i = 0; i < dim; ++i) {
+      mb->c[supPoint][i] = mb->c[supPoint - 1][i] + f * mb->v[supPoint][i];
+    }
+    mb->sqr_r[supPoint] = mb->sqr_r[supPoint - 1] + e * f / 2;
+  }
+
+  mb->current_c = mb->c[supPoint];
+  mb->current_sqr_r = mb->sqr_r[supPoint];
+  mb->s = ++mb->m;
+  return 1;
+}
+
+void MiniballBuilder_pop(MiniballBuilder* mb) {
+  mb->m--;
+}
+
+double MiniballBuilder_slack(MiniballBuilder* mb) {
+  double* l = malloc(sizeof(double) * (mb->d + 1));
+  double min_l = 0;
+  l[0] = 1;
+
+  int i, k;
+  for(i = mb->s - 1; i > 0; --i) {
+    l[i] = mb->f[i];
+    for(k = mb->s - 1; k > i; --k) {
+      l[i] -= mb->a[k][i] * l[k];
+    }
+    if(l[i] < min_l) {
+      min_l = l[i];
+    }
+    l[0] -= l[i];
+  }
+
+  if(l[0] < min_l) {
+    min_l = l[0];
+  }
+
+  free(l);
+
+  return ((min_l < 0) ? -min_l : 0);
+}
+

data/ext/miniball_ruby/miniball_builder_dynamic_d.h

@@ -0,0 +1,43 @@
+#ifndef __MINIBALL_B_DYNAMIC_D__
+#define __MINIBALL_B_DYNAMIC_D__
+
+#include "point_dynamic_d.h"
+
+//Smallest enclosing ball with a set of n <= d+1 points *on the boundry*
+typedef struct MiniballBuilder MiniballBuilder;
+
+struct MiniballBuilder {
+  int d; //Dimension
+  int m, s; //Size and number of support points
+  double* q0;
+
+  double*  z;
+  double*  f;
+  double** v;
+  double** a;
+
+  double** c;
+  double*  sqr_r;
+    
+  double*  current_c; //Refers to some c[j]
+  double   current_sqr_r;  
+};
+
+MiniballBuilder* MiniballBuilder_create(int dim);
+void MiniballBuilder_destroy(MiniballBuilder* mb);
+
+const double* MiniballBuilder_center(MiniballBuilder* mb);
+double MiniballBuilder_squared_radius(MiniballBuilder* mb);
+
+int MiniballBuilder_size(MiniballBuilder* mb);
+int MiniballBuilder_support_size(MiniballBuilder* mb);
+double MiniballBuilder_excess(MiniballBuilder* mb, const Point* p);
+
+void MiniballBuilder_reset(MiniballBuilder* mb);
+
+int MiniballBuilder_push(MiniballBuilder* mb, Point* p);
+void MiniballBuilder_pop(MiniballBuilder* mb);
+
+double MiniballBuilder_slack(MiniballBuilder* mb);
+
+#endif

data/ext/miniball_ruby/miniball_dynamic_d.c

@@ -0,0 +1,207 @@
+#include <stdlib.h>
+#include "util.h"
+#include "point_dynamic_d.h"
+#include "miniball_builder_dynamic_d.h"
+#include "miniball_dynamic_d.h"
+
+Miniball* Miniball_create(int dim) {
+  Miniball* m = malloc(sizeof(Miniball));
+  
+  m->d = dim;
+  m->B = MiniballBuilder_create(dim);
+
+  m->firstPoint = 0;
+  m->lastPoint = 0;
+  m->pointCount = 0;
+
+  return m;
+}
+
+void Miniball_destroy(Miniball* m) {
+  if(m->firstPoint != 0) {
+    Point* p = m->firstPoint;
+    while(p) {
+      Point* next = p->next;
+      Point_destroy(p);
+      p = next;
+    }
+  }
+  MiniballBuilder_destroy(m->B);
+  free(m);
+}
+
+void Miniball_check_in(Miniball* m, Point* p) {
+  if(m->firstPoint == 0) {
+    m->firstPoint = p;
+    m->lastPoint = p;
+  } else {
+    p->prev = m->lastPoint;
+    m->lastPoint->next = p;
+    m->lastPoint = p;
+  }
+  m->pointCount++;
+}
+
+void Miniball_build(Miniball* m) {
+  //The c++ version used std::list::end, which is _beyond_ the last element
+  //Tack a fake point on to the end of our list to emulate this, while avoiding
+  //any segfaults in post-run analysis that would be caused by using void.
+  Point* hack = Point_create(m->d);
+  Miniball_check_in(m, hack);
+
+  MiniballBuilder_reset(m->B);
+  m->support_end = m->firstPoint;
+  Miniball_pivot_mb(m, m->lastPoint);
+}
+
+void Miniball_move_to_front(Miniball* m, Point* p) {
+  if(m->support_end == p) {
+    m->support_end = p->next;
+  }
+
+  if(m->firstPoint == p) {
+    return;
+  }
+
+  if(p->prev) {
+    p->prev->next = p->next;
+  }
+  if(p->next) {
+    p->next->prev = p->prev;
+  }
+  m->firstPoint->prev = p;
+  p->next = m->firstPoint;
+  p->prev = 0;
+  m->firstPoint = p;
+}
+
+void Miniball_mtf_mb(Miniball* m, Point* i) {
+  m->support_end = m->firstPoint;
+  if(MiniballBuilder_size(m->B) == m->d + 1) {
+    return;
+  }
+
+  Point* k = m->firstPoint;
+  while(k != i) {
+    Point* next = k->next;
+    if(MiniballBuilder_excess(m->B, k) > 0) {
+      if(MiniballBuilder_push(m->B, k)) {
+        Miniball_mtf_mb(m, k);
+        MiniballBuilder_pop(m->B);
+        Miniball_move_to_front(m, k);
+      }
+    }
+    k = next;
+  }
+}
+
+void Miniball_pivot_mb(Miniball* m, Point* p) {
+  Point* t = m->firstPoint->next;
+  Miniball_mtf_mb(m, t);
+
+  double max_e, old_sqr_r = -1;
+
+  do {
+    Point* pivot;
+    max_e = Miniball_max_excess(m, t, p, &pivot);
+    if(max_e > 0) {
+      t = m->support_end;
+      if(t == pivot) {
+        t = t->next;
+      }
+      old_sqr_r = MiniballBuilder_squared_radius(m->B);
+      MiniballBuilder_push(m->B, pivot);
+      Miniball_mtf_mb(m, m->support_end);
+      MiniballBuilder_pop(m->B);
+      Miniball_move_to_front(m, pivot);
+    }
+  } while((max_e > 0) && (MiniballBuilder_squared_radius(m->B) > old_sqr_r));
+}
+
+double Miniball_max_excess(Miniball* m, Point* t, Point* i, Point** pivot) {
+  const double* c = MiniballBuilder_center(m->B);
+  const double sqr_r = MiniballBuilder_squared_radius(m->B);
+  double e, max_e = 0;
+
+  Point* k = t;
+  while(k != i) {
+    e = -sqr_r;
+    int j;
+    for(j = 0; j < m->d; ++j) {
+      e += sqr(k->coord[j] - c[j]);
+    }
+    if(e > max_e) {
+      max_e = e;
+      *pivot = k;
+    }
+    k = k->next;
+  }
+
+  return max_e;
+}
+
+Point* Miniball_center(Miniball* m) {
+  Point* p = Point_create(m->d);
+  Point_copy_dbl(p, MiniballBuilder_center(m->B));
+  return p;
+}
+
+double Miniball_squared_radius(Miniball* m) {
+  return MiniballBuilder_squared_radius(m->B);
+}
+
+int Miniball_nr_points(Miniball* m) {
+  return m->pointCount;
+}
+
+Point* Miniball_points_begin(Miniball* m) {
+  return m->firstPoint;
+}
+
+Point* Miniball_points_end(Miniball* m) {
+  return m->lastPoint;
+}
+
+int Miniball_nr_support_points(Miniball* m) {
+  return MiniballBuilder_support_size(m->B);
+}
+
+Point* Miniball_support_points_begin(Miniball* m) {
+  return m->firstPoint;
+}
+
+Point* Miniball_support_points_end(Miniball* m) {
+  return m->support_end;
+}
+
+double Miniball_accuracy(Miniball* m, double* slack) {
+  double e, max_e = 0;
+  int n_supp = 0;
+  Point* i = m->firstPoint;
+  while(i != m->support_end) {
+    e = MiniballBuilder_excess(m->B, i);
+    if(e < 0) {
+      e = -e;
+    }
+    if(e > max_e) {
+      max_e = e;
+    }
+    i = i->next;
+  }
+
+  while(i != m->lastPoint) {
+    e = MiniballBuilder_excess(m->B, i);
+    if(e > max_e) {
+      max_e = e;
+    }
+    i = i->next;
+  }
+
+  *slack = MiniballBuilder_slack(m->B);
+  return (max_e / Miniball_squared_radius(m));
+}
+
+int Miniball_is_valid(Miniball* m, double tolerance) {
+  double slack;
+  return ((Miniball_accuracy(m, &slack) < tolerance) && (slack == 0));
+}

data/ext/miniball_ruby/miniball_dynamic_d.h

@@ -0,0 +1,43 @@
+#ifndef __MINIBALL_DYNAMIC_D__
+#define __MINIBALL_DYNAMIC_D__
+
+#include "point_dynamic_d.h"
+#include "miniball_builder_dynamic_d.h"
+
+//Smallest enclosing ball of a set of n points in dimension d
+typedef struct Miniball Miniball;
+
+struct Miniball {
+  int d; //Dimension
+  MiniballBuilder* B; //The current ball
+
+  Point* firstPoint; //Start of internal point set
+  Point* lastPoint; //End of internal point set
+  int pointCount;
+
+  Point* support_end; //Past-the end iterator of support set
+};
+
+Miniball* Miniball_create(int dim);
+void Miniball_destroy(Miniball* m);
+
+void Miniball_check_in(Miniball* m, Point* p);
+void Miniball_build(Miniball* m);
+void Miniball_move_to_front(Miniball* m, Point* p);
+void Miniball_mtf_mb(Miniball* m, Point* i);
+void Miniball_pivot_mb(Miniball* m, Point* p);
+
+double Miniball_max_excess(Miniball* m, Point* t, Point* i, Point** pivot);
+
+Point* Miniball_center(Miniball* m);
+double Miniball_squared_radius(Miniball* m);
+int Miniball_nr_points(Miniball* m);
+Point* Miniball_points_begin(Miniball* m);
+Point* Miniball_points_end(Miniball* m);
+int Miniball_nr_support_points(Miniball* m);
+Point* Miniball_support_points_begin(Miniball* m);
+Point* Miniball_support_points_end(Miniball* m);
+double Miniball_accuracy(Miniball* m, double* slack);
+int Miniball_is_valid(Miniball* m, double tolerance);
+
+#endif

data/ext/miniball_ruby/miniball_ruby.c

@@ -0,0 +1,169 @@
+//TODO: Can push some more c ruby into this (and dependencies), like ALLOC
+
+#include "ruby.h"
+#include "util.h"
+#include "point_dynamic_d.h"
+#include "miniball_builder_dynamic_d.h"
+#include "miniball_dynamic_d.h"
+
+//
+// Calculation result structue and accessors
+//
+
+VALUE MiniballResult;
+
+typedef struct Result Result;
+
+struct Result {
+  VALUE center;
+  VALUE radius_squared;
+  VALUE support_points;
+  VALUE accuracy;
+  VALUE slack;
+};
+
+Result* ConstructResult(int dim, double* center, double radius_squared) {
+  Result* r = malloc(sizeof(Result));
+
+  r->center = rb_ary_new2(dim);
+  int i;
+  for(i = 0; i < dim; ++i) {
+    rb_ary_store(r->center, i, rb_float_new(center[i]));
+  }
+
+  r->radius_squared = rb_float_new(radius_squared);
+
+  r->support_points = Qnil;
+  r->accuracy = Qnil;
+  r->slack = Qnil;
+
+  return r;
+}
+
+void MarkResult(Result* r) {
+  rb_gc_mark(r->center);
+  rb_gc_mark(r->radius_squared);
+  rb_gc_mark(r->support_points);
+  rb_gc_mark(r->accuracy);
+  rb_gc_mark(r->slack);
+}
+
+void DestroyResult(Result* r) {
+  free(r);
+}
+
+VALUE center(VALUE self) {
+  Result* r;
+  Data_Get_Struct(self, Result, r);
+  return r->center;
+}
+
+VALUE radius_squared(VALUE self) {
+  Result* r;
+  Data_Get_Struct(self, Result, r);
+  return r->radius_squared;
+}
+
+VALUE support_points(VALUE self) {
+  Result* r;
+  Data_Get_Struct(self, Result, r);
+  return r->support_points;
+}
+
+VALUE accuracy(VALUE self) {
+  Result* r;
+  Data_Get_Struct(self, Result, r);
+  return r->accuracy;
+}
+
+VALUE slack(VALUE self) {
+  Result* r;
+  Data_Get_Struct(self, Result, r);
+  return r->slack;
+}
+
+
+
+//
+// Calculation methods
+//
+
+VALUE MiniballC;
+
+static VALUE calc(VALUE self, VALUE points, VALUE with_analytics) {
+  Check_Type(points, T_ARRAY);
+  if(RARRAY_LEN(points) == 0) {
+    rb_raise(rb_eArgError, "Must have at least one point");
+  }
+
+  Check_Type(rb_ary_entry(points, 0), T_ARRAY);
+  int dim = RARRAY_LEN(rb_ary_entry(points, 0));
+
+  Miniball* m = Miniball_create(dim);
+
+  int i, j;
+  int len =  RARRAY_LEN(points);
+  for(i = 0; i < len; ++i) {
+    VALUE point = rb_ary_entry(points, i);
+    Check_Type(point, T_ARRAY);
+    if(RARRAY_LEN(point) != dim) {
+      rb_raise(rb_eArgError, "Point dimensions must be consistent");
+    }
+
+    Point* p = Point_create(dim);
+    for(j = 0; j < dim; ++j) {
+      p->coord[j] = NUM2DBL(rb_ary_entry(point, j));
+    }
+    Miniball_check_in(m, p);
+  }
+
+  Miniball_build(m);
+
+  Point* center = Miniball_center(m);
+  double radius_squared = Miniball_squared_radius(m);
+  //TODO: Support points
+
+  Result* r = ConstructResult(dim, center->coord, radius_squared);
+
+  int support_point_count = Miniball_nr_support_points(m);
+  r->support_points = rb_ary_new2(support_point_count);
+
+  Point* support_point = Miniball_support_points_begin(m);
+  for(i = 0; i < support_point_count; i++, support_point = support_point->next) {
+    VALUE point = rb_ary_new2(dim);
+    for(j = 0; j < dim; ++j) {
+      rb_ary_store(point, j, rb_float_new(support_point->coord[j]));
+    }
+    rb_ary_store(r->support_points, i, point);
+  }
+
+  if(with_analytics) {
+    double slack;
+    r->accuracy = rb_float_new(Miniball_accuracy(m, &slack));
+    r->slack = slack;
+  }
+
+  VALUE result = Data_Wrap_Struct(MiniballResult, MarkResult, DestroyResult, r);
+
+  Miniball_destroy(m);
+  return result;
+}
+
+
+
+//
+// Ruby init
+//
+
+void Init_miniball_ruby() {
+  MiniballC = rb_define_module("MiniballC");
+  rb_define_method(MiniballC, "calc", calc, 2);
+
+  MiniballResult = rb_define_class("MiniballResult", rb_cObject);
+  rb_define_method(MiniballResult, "center", center, 0);
+  rb_define_method(MiniballResult, "radius_squared", radius_squared, 0);
+  rb_define_method(MiniballResult, "support_points", support_points, 0);
+  rb_define_method(MiniballResult, "accuracy", accuracy, 0);
+  rb_define_method(MiniballResult, "slack", slack, 0);
+}
+

data/ext/miniball_ruby/point_dynamic_d.c

@@ -0,0 +1,47 @@
+#include <stdlib.h>
+#include "point_dynamic_d.h"
+
+Point* Point_create(int dim) {
+  Point* p = malloc(sizeof(Point));
+
+  p->d = dim;
+  p->coord = malloc(sizeof(double) * dim);
+
+  p->prev = 0;
+  p->next = 0;
+
+  return p;
+}
+
+void Point_destroy(Point* p) {
+  free(p->coord);
+  free(p);
+}
+
+void Point_copy_dbl(Point* dest, const double* source) {
+  int sourceDim = sizeof(source) / sizeof(double);
+  //assert(dest->d == sourceDim);
+  int i;
+  for(i = 0; i < dest->d; ++i) {
+    dest->coord[i] = source[i];
+  }
+}
+
+void Point_copy(Point* dest, const Point* source) {
+  int i;
+  if(dest->d != source->d) {
+    free(dest->coord);
+    dest->coord = malloc(sizeof(double) * source->d);
+    dest->d = source->d;
+  }
+
+  Point_copy_dbl(dest, source->coord);
+}
+
+double* Point_begin(Point* p) {
+  return p->coord;
+}
+
+double* Point_end(Point* p) {
+  return p->coord + p->d;
+}

data/ext/miniball_ruby/point_dynamic_d.h

@@ -0,0 +1,24 @@
+#ifndef __POINT__
+#define __POINT__
+
+typedef struct Point Point;
+
+struct Point {
+  int d;
+  double* coord;
+
+  //Points can be used as doubly-linked lists (must free manually)
+  Point* prev;
+  Point* next;
+};
+
+Point* Point_create(int dim);
+void   Point_destroy(Point* p);
+
+void Point_copy_dbl(Point* dest, const double* source);
+void Point_copy(Point* dest, const Point* source);
+
+double* Point_begin(Point* p);
+double* Point_end(Point* p);
+
+#endif

data/ext/miniball_ruby/util.c

@@ -0,0 +1,6 @@
+#include "util.h"
+
+inline double sqr(double r) {
+  return r * r;
+}
+

data/ext/miniball_ruby/util.h

@@ -0,0 +1,7 @@
+#ifndef __MINIBALL_UTIL__
+#define __MINIBALL_UTIL__
+
+inline double sqr(double r);
+
+#endif
+

data/lib/miniball.rb

@@ -0,0 +1 @@
+require File.expand_path('../miniball_ruby/miniball', __FILE__)

data/lib/miniball_ruby/miniball.rb

@@ -0,0 +1,48 @@
+require 'miniball_ruby/miniball_ruby'
+
+class Miniball
+  include MiniballC
+
+  def initialize(points)
+    @result = nil
+    @points = points
+  end
+
+  def calculate(with_analysis = false)
+    @result ||= calc(@points, with_analysis || false)
+  end
+
+  def center
+    calculate.center
+  end
+
+  def radius
+    @radius ||= radius_squared ** 0.5
+  end
+
+  def radius_squared
+    calculate.radius_squared
+  end
+
+  def support_points
+    calculate.support_points
+  end
+
+  #Must calculate with analytics on to get accuracy or slack
+
+  def accuracy
+    unless @accuracy
+      a = calculate.accuracy
+      @accuracy = a.nan? ? 0.0 : a
+    end
+    @accuracy
+  end
+
+  def slack
+    unless @slack
+      s = calculate.slack
+      @slack = (s == false ? 0.0 : slack)
+    end
+    @slack
+  end
+end

data/lib/miniball_ruby/version.rb

@@ -0,0 +1,3 @@
+class Miniball
+  VERSION = '0.0.2'
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: miniball_ruby
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Mike Marion
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-27 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: |-
+  This gem finds minimum bounding spheres of a set of points.
+                       It is a port of Bernd Gaertner's C++ miniball library.
+email: mike.marion@gmail.com
+executables: []
+
+extensions: 
+- ext/miniball_ruby/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- lib/miniball_ruby/miniball.rb
+- lib/miniball_ruby/version.rb
+- lib/miniball.rb
+- ext/miniball_ruby/miniball_builder_dynamic_d.h
+- ext/miniball_ruby/point_dynamic_d.o
+- ext/miniball_ruby/util.c
+- ext/miniball_ruby/miniball_builder_dynamic_d.c
+- ext/miniball_ruby/extconf.rb
+- ext/miniball_ruby/miniball_dynamic_d.o
+- ext/miniball_ruby/miniball_ruby.o
+- ext/miniball_ruby/point_dynamic_d.c
+- ext/miniball_ruby/util.h
+- ext/miniball_ruby/miniball_ruby.so
+- ext/miniball_ruby/miniball_dynamic_d.c
+- ext/miniball_ruby/miniball_builder_dynamic_d.o
+- ext/miniball_ruby/miniball_ruby.c
+- ext/miniball_ruby/Makefile
+- ext/miniball_ruby/util.o
+- ext/miniball_ruby/point_dynamic_d.h
+- ext/miniball_ruby/miniball_dynamic_d.h
+homepage: https://github.com/marionm/miniball_ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Ruby/C implementation of miniball
+test_files: []
+