fastcluster 0.9

data/CHANGELOG

@@ -0,0 +1,2 @@
+v0.9 In testing
+v0.1 Initial version

data/Manifest

@@ -0,0 +1,14 @@
+CHANGELOG
+Manifest
+README.rdoc
+Rakefile
+ext/clusterer.c
+ext/extconf.rb
+lib/fastcluster.rb
+lib/fastcluster/cluster.rb
+spec/lib/fastcluster/cluster_spec.rb
+spec/lib/fastcluster/clusterer_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+spec/test_data.rb
+test.rb

data/README.rdoc

@@ -0,0 +1,59 @@
+
+= Simple and fast clustering library
+
+* http://github.com/jemmyw/fastcluster
+
+== DESCRIPTION
+
+This gem provides a really simple way to cluster 2 dimensional points. It is based
+on the Hierclust[http://hierclust.rubyforge.org/] gem by Brandt Kurowski,
+except that it does not cluster hierarchically. The aim of this gem is to provide
+the same clustering algorithm but to be as fast as possible.
+
+== INSTALL:
+
+* sudo gem install fastcluster
+
+== EXAMPLE:
+
+  require 'fastcluster'
+  points = [[1, 1], [1, 2], [5, 9]]
+  clusterer = Fastcluster::Clusterer.new(3, 0, points)
+  clusterer.clusters.each do |cluster|
+    puts cluster.x
+    puts cluster.y
+    puts cluster.size
+  end
+
+== ALGORITHM:
+
+1.   All points are initially clusters with size 1
+2.   Precluster - create a grid of size [resolution] and cluster the points in each grid space automatically
+3.   Combine two closest clusters, the new cluster has the summed size and the averaged distance (size weighted)
+     between the clusters.
+4.   Loop to 3 until no cluster is less that [separation] apart or only one cluster remains
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Jeremy Wells
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'spec'
+require 'spec/rake/spectask'
+require 'echoe'
+
+Echoe.new("fastcluster") do |p|
+  p.author = "Jeremy Wells"
+  p.email = "jeremy@boost.co.nz"
+  p.summary = "A clustering library for 2 dimensional points"
+  p.description = "A clustering library for 2 dimensional points"
+  p.url = "http://github.com/jemmyw/fastcluster"
+end

data/ext/clusterer.c

@@ -0,0 +1,325 @@
+#include <ruby.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+/*
+*
+* Algorithm:
+*   all points are initially clusters with size 1
+*   precluster - create a grid of size @resolution and cluster the points in each grid space automatically
+*   loop until no cluster is less that @separation apart
+*     combine two closest clusters, the new cluster has the summed size and the averaged distance (size weighted)
+*     between the clusters.
+**/
+typedef struct {
+  double x;
+  double y;
+  long size;
+} CLUSTER;
+
+/*
+* An array of points to be clustered.
+*/
+static VALUE fc_get_points(VALUE self) {
+  return rb_iv_get(self, "@points");
+}
+
+/*
+* call-seq:
+*   add(x, y) -> nil
+*
+* Add a point to this clusterer.
+*/
+static VALUE fc_add_point(VALUE self, VALUE x, VALUE y) {
+  long len = 2;
+  VALUE holdArray = rb_ary_new3(2, x, y);
+  VALUE pointArray = fc_get_points(self);
+  rb_ary_push(pointArray, holdArray);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   <<(point) -> nil
+ *
+ * Add a point to this clusterer. The point must be in the format
+ * of an array with two number.
+ *
+ * Example:
+ *  clusterer << [1, 2]
+ */
+static VALUE fc_append_point(VALUE self, VALUE point) {
+  VALUE pointArray = fc_get_points(self);
+  rb_ary_push(pointArray, point);
+  return Qnil;
+}
+
+/*
+* Calculate the distance (pythag) between two cluster points
+*/
+static double fc_get_distance_between(CLUSTER * one, CLUSTER * two) {
+  double rr = pow((long)one->x - (long)two->x, 2) + pow((long)one->y - (long)two->y, 2);
+  return sqrt(rr);
+}
+
+/*
+* Add a point to a cluster. This increments the size and calcualtes the average between
+* the current cluster position and the new point.
+*/
+static void fc_add_to_cluster(CLUSTER * dst, double x, double y) {
+  dst->x = ((dst->x * dst->size) + x) / (dst->size + 1);
+  dst->y = ((dst->y * dst->size) + y) / (dst->size + 1);
+  dst->size++;
+}
+
+/*
+* Combine two clusters into one with an average center point
+*/
+static void fc_combine_clusters(CLUSTER * dst, CLUSTER * src) {
+  dst->x = (dst->x*dst->size + src->x*src->size) / (dst->size+src->size);
+  dst->y = (dst->y*dst->size + src->y*src->size) / (dst->size+src->size);
+  dst->size = dst->size + src->size;
+}
+
+/*
+* Get the maximum grid size
+*/
+static long fc_get_max_grid(long resolution, CLUSTER * point_array, long num_points) {
+  int i;
+  int max_grid = 0;
+  for(i = 0; i < num_points; i++) {
+    CLUSTER * point = &point_array[i];
+    int xg = point->x/resolution;
+    int yg = point->y/resolution;
+    if(xg>max_grid)
+      max_grid = xg;
+    if(yg>max_grid)
+      max_grid = yg;
+  }
+  return max_grid+1;
+}
+
+/*
+* call-seq:
+*   new(separation = 0, resolution = 0, points = nil)
+*
+* Create a new Clusterer. The new method accepts 3 optional arguments, separation,
+* resolution and points.
+*
+* <tt>separation</tt> - The distance between clusters. The higher this number, the
+* less clusters there will be. If this is 0 then no clustering will occur.
+*
+* <tt>resolution</tt> - If specified then the points are placed on a grid with each grid square
+* being this size. Points falling in the same grid square are automatically clustered.
+* This option should be specified clustering larger number of points to reduce processing time.
+*
+* <tt>points</tt> - An array of points. Each array item must be an array with
+* two numbers (x, y). Example: <code>[[1, 2], [3, 4]]</code>.
+*/
+static VALUE fc_initialize_clusterer(int argc, VALUE *argv, VALUE self) {
+  if(argc > 0)
+    rb_iv_set(self, "@separation", argv[0]);
+  else
+    rb_iv_set(self, "@separation", INT2FIX(0));
+
+  if(argc > 1)
+    rb_iv_set(self, "@resolution", argv[1]);
+  else
+    rb_iv_set(self, "@resolution", INT2FIX(0));
+
+  VALUE pointArray = rb_ary_new();
+  rb_iv_set(self, "@points", pointArray);
+
+  if(argc > 2) {
+    if(TYPE(argv[2]) == T_ARRAY) {
+      rb_iv_set(self, "@points", argv[2]);
+    }
+  }
+
+  return Qnil;
+}
+
+/*
+* Turn the ruby array of points (format [[x,y], [x,y]]) into an array of
+* CLUSTER
+*/
+static void fc_native_point_array(CLUSTER * arrayPtr, VALUE rubyArray, long num_points) {
+  int i;
+  for(i=0;i<num_points;i++) {
+    VALUE holdArray = RARRAY(rubyArray)->ptr[i];
+    double x = NUM2DBL(RARRAY(holdArray)->ptr[0]);
+    double y = NUM2DBL(RARRAY(holdArray)->ptr[1]);
+
+    arrayPtr[i].x = x;
+    arrayPtr[i].y = y;
+    arrayPtr[i].size = 1;
+  }
+}
+
+static CLUSTER *fc_calculate_clusters(long separation, long resolution, CLUSTER * point_array, int num_points, long * cluster_size) {
+  int max_grid = fc_get_max_grid(resolution, &point_array[0], num_points);
+  int i, j;
+  long preclust_size = 0;
+
+  CLUSTER * cluster;
+  CLUSTER * clusters;
+
+  if(resolution > 0) {
+    CLUSTER grid_array[max_grid][max_grid];
+
+    for(i=0;i<max_grid;i++) {
+      for(j=0;j<max_grid;j++) {
+        grid_array[i][j].size = 0;
+      }
+    }
+
+    for(i = 0; i < num_points; i++) {
+      cluster = &point_array[i];
+
+      int gx = floor(cluster->x/resolution);
+      int gy = floor(cluster->y/resolution);
+
+      fc_add_to_cluster(&grid_array[gx][gy], cluster->x, cluster->y);
+
+      if(grid_array[gx][gy].size == 1) preclust_size++;
+    }
+
+    clusters = malloc(preclust_size * sizeof(CLUSTER));
+
+    int max_grid_total = max_grid * max_grid;
+    CLUSTER * gridPtr = grid_array[0];
+
+    int incr = 0;
+    for(i=0;i<max_grid_total;i++) {
+      if(gridPtr[i].size > 0) {
+        clusters[incr] = gridPtr[i];
+        incr++;
+      }
+    }
+  } else {
+    preclust_size = num_points;
+    clusters = malloc(preclust_size * sizeof(CLUSTER));
+    memcpy(&clusters[0], &point_array[0], preclust_size * sizeof(CLUSTER));
+  }
+
+  double distance_sep = 0;
+  long current_cluster_size = 0;
+  int found;
+  long nearest_origin;
+  long nearest_other;
+
+  do {
+    // calculate distance sep
+    distance_sep = 0;
+    nearest_other = 0;
+
+    for(i=0;i<preclust_size;i++){
+      for(j=i+1;j<preclust_size;j++){
+        double distance = fc_get_distance_between(&clusters[i], &clusters[j]);
+
+//        printf("distance between %f, %f and %f, %f is %f\n", clusters[i].x, clusters[i].y, clusters[j].x, clusters[j].y, distance);
+
+        if(distance_sep == 0 || distance < distance_sep) {
+          distance_sep = distance;
+
+          if(distance < separation || separation == 0) {
+          nearest_origin = i;
+          nearest_other = j;
+          }
+        }
+      }
+    }
+
+    if(nearest_other > 0) {
+      fc_combine_clusters(&clusters[nearest_origin], &clusters[nearest_other]);
+
+      CLUSTER *newarr = malloc(preclust_size * sizeof(CLUSTER));
+      memcpy(&newarr[0], &clusters[0], nearest_other * sizeof(CLUSTER));
+      memcpy(&newarr[nearest_other], &clusters[nearest_other+1], (preclust_size - (nearest_other + 1)) * sizeof(CLUSTER));
+
+      void *_tmp = realloc(clusters, ((preclust_size-1) * sizeof(CLUSTER)));
+      clusters = (CLUSTER*)_tmp;
+      preclust_size = preclust_size - 1;
+
+      for(i=0;i<preclust_size;i++)
+        clusters[i] = newarr[i];
+
+      free(newarr);
+    }
+
+  } while((separation == 0 || distance_sep < separation) && preclust_size > 1);
+
+  *cluster_size = preclust_size;
+  return clusters;
+}
+
+static VALUE fc_get_cluster_class() {
+  ID cluster_module_id = rb_intern("Fastcluster");
+  ID cluster_class_id = rb_intern("Cluster");
+  VALUE cluster_module = rb_const_get(rb_cObject, cluster_module_id);
+  return rb_const_get(cluster_module, cluster_class_id);
+}
+
+/*
+* Return the clusters found for the points in this clusterer. This will be an
+* array of Cluster objects.
+*
+* Example:
+*   clusterer = Fastcluster::Clusterer.new(3, 0, [[1, 1], [1, 2], [5, 9]])
+*   clusterer.clusters -> [(1.00, 1.50): 2, (5.00, 9.00): 1]
+*/
+static VALUE fc_get_clusters(VALUE self) {
+  // Get the separation adn resolution from ruby
+  long separation = NUM2INT(rb_iv_get(self, "@separation"));
+  long resolution = NUM2INT(rb_iv_get(self, "@resolution"));
+  int i;
+
+  // Create a native array of clusters from the ruby array of points
+  VALUE pointArray = fc_get_points(self);
+  long num_points = RARRAY(pointArray)->len;
+  CLUSTER native_point_array[num_points];
+
+  fc_native_point_array(&native_point_array[0], pointArray, num_points);
+
+  // Calcualte the clusters
+  CLUSTER * clusters = NULL;
+  long cluster_size;
+
+  clusters = fc_calculate_clusters(separation, resolution, &native_point_array[0], num_points, &cluster_size);
+
+  // Create ruby array of clusters to return
+  VALUE cluster_class = fc_get_cluster_class();
+  VALUE ruby_cluster_array = rb_ary_new2(cluster_size);
+
+  for(i=0;i<cluster_size;i++) {
+    int arg_count = 3;
+    VALUE arg_array[arg_count];
+
+    arg_array[0] = rb_float_new(clusters[i].x);
+    arg_array[1] = rb_float_new(clusters[i].y);
+    arg_array[2] = INT2FIX(clusters[i].size);
+
+    VALUE cluster_obj = rb_class_new_instance(arg_count, arg_array, cluster_class);
+    rb_ary_push(ruby_cluster_array, cluster_obj);
+  }
+
+  // Free the clusters array
+  free(clusters);
+
+  return ruby_cluster_array;
+}
+
+void Init_clusterer() {
+  VALUE clustererModule = rb_define_module("Fastcluster");
+  VALUE clustererClass = rb_define_class_under(clustererModule, "Clusterer", rb_cObject);
+
+  rb_define_method(clustererClass, "initialize", fc_initialize_clusterer, -1);
+  rb_define_method(clustererClass, "add", fc_add_point, 2);
+
+  rb_define_method(clustererClass, "<<", fc_append_point, 1);
+
+  rb_define_method(clustererClass, "clusters", fc_get_clusters, 0);
+  rb_define_method(clustererClass, "points", fc_get_points, 0);
+}

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = 'clusterer'
+dir_config(extension_name)
+create_makefile(extension_name)

data/fastcluster.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fastcluster}
+  s.version = "0.9"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jeremy Wells"]
+  s.date = %q{2009-10-24}
+  s.description = %q{A clustering library for 2 dimensional points}
+  s.email = %q{jeremy@boost.co.nz}
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = ["CHANGELOG", "README.rdoc", "ext/clusterer.c", "ext/extconf.rb", "lib/fastcluster.rb", "lib/fastcluster/cluster.rb"]
+  s.files = ["CHANGELOG", "Manifest", "README.rdoc", "Rakefile", "ext/clusterer.c", "ext/extconf.rb", "lib/fastcluster.rb", "lib/fastcluster/cluster.rb", "spec/lib/fastcluster/cluster_spec.rb", "spec/lib/fastcluster/clusterer_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "spec/test_data.rb", "test.rb", "fastcluster.gemspec"]
+  s.homepage = %q{http://github.com/jemmyw/fastcluster}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Fastcluster", "--main", "README.rdoc"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{fastcluster}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A clustering library for 2 dimensional points}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/fastcluster.rb

@@ -0,0 +1,4 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'fastcluster/cluster'
+require File.dirname(__FILE__) + '/clusterer'

data/lib/fastcluster/cluster.rb

@@ -0,0 +1,25 @@
+module Fastcluster
+  class Cluster
+    include Comparable
+
+    attr_reader :x, :y, :size
+
+    def initialize(x, y, size)
+      @x = x
+      @y = y
+      @size = size
+    end
+
+    def <=>(anOther)
+      size <=> anOther.size
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_s
+      '(%0.2f, %0.2f): %d' % [@x, @y, @size]
+    end
+  end
+end

data/spec/lib/fastcluster/clusterer_spec.rb

@@ -0,0 +1,222 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'benchmark'
+
+describe Fastcluster::Clusterer do
+  before do
+    @points = POINTS
+  end
+
+  it 'should allow setting points in initializer' do
+    @clusterer = Fastcluster::Clusterer.new(105, 5, @points)
+    @clusterer.points.size.should == 168
+  end
+
+  describe 'instance' do
+    before do
+      @clusterer = Fastcluster::Clusterer.new(105, 5)
+    end
+
+    describe '#add' do
+      it 'should add an x y point to the clusterer' do
+        @clusterer.add(5, 10)
+        @clusterer.points.size.should == 1
+        @clusterer.points.first.should == [5, 10]
+      end
+    end
+
+    describe '#<<' do
+      it 'should add the value to the clusterer' do
+        @clusterer << [5, 10]
+        @clusterer.points.size.should == 1
+        @clusterer.points.first.should == [5, 10]
+      end
+    end
+  end
+
+  describe '#clusters' do
+    describe 'with large test' do
+      before do
+        @clusterer = Fastcluster::Clusterer.new(105, 5, @points)
+        @clusters = @clusterer.clusters.sort{|a, b| a.size == b.size ? a.x <=> b.x : a.size <=> b.size }
+      end
+
+      it 'should take less than 1 second' do
+        time = Benchmark.measure { @clusterer.clusters }
+        time.total.should be < 1
+      end
+
+      it 'should have as many cluster points as data points' do
+        @clusters.inject(0){|m, n| m + n.size }.should == @points.size
+      end
+
+      it 'should have 23 clusters' do
+        @clusters.size.should == 23
+      end
+
+      it 'should have a cluster of 108 points at 836 by 178' do
+        @clusters.last.size.should == 108
+        @clusters.last.x.should be_close(836, 1)
+        @clusters.last.y.should be_close(178, 1)
+      end
+
+      it 'should have a cluster of 1 point at 97 by 1203' do
+        @clusters.first.size.should == 1
+        @clusters.first.x.should be_close(97, 1)
+        @clusters.first.y.should be_close(1203, 1)
+      end
+    end
+
+    describe "with two points" do
+      before do
+        @clusterer = Fastcluster::Clusterer.new(0, 0, [[1, 5], [2, 8]])
+      end
+
+      it "should return one cluster" do
+        @clusterer.clusters.size.should == 1
+      end
+
+      it "should have two points in the cluster" do
+        @clusterer.clusters.first.size.should == 2
+      end
+    end
+
+    describe "with three points" do
+      before do
+        @clusterer = Fastcluster::Clusterer.new(0, 0, [[1, 2], [5, 6], [2, 3]])
+        @clusters = @clusterer.clusters
+      end
+
+      it "should return one cluster" do
+        @clusters.size.should == 1
+      end
+
+      it "containing three items" do
+        @clusters.first.size.should == 3
+      end
+    end
+
+    describe "with four points" do
+      before do
+        @points = [
+            [0, 1],
+            [1, 0],
+            [3, 4],
+            [4, 3],
+        ]
+      end
+
+      describe "and no separation" do
+        before do
+          @clusterer = Fastcluster::Clusterer.new(0, 0, @points)
+        end
+
+        it "should return one cluster" do
+          @clusterer.clusters.size.should == 1
+        end
+      end
+
+      describe "and separation 1" do
+        before do
+          require 'lib/fastcluster'
+          @clusterer = Fastcluster::Clusterer.new(1, 0, @points)
+        end
+
+        it "should return all four individual points" do
+          @clusterer.clusters.size.should == 4
+        end
+      end
+
+      describe "and separation 2" do
+        before do
+          @clusterer = Fastcluster::Clusterer.new(2, 0, @points)
+        end
+
+        it "should return two clusters" do
+          @clusterer.clusters.size.should == 2
+        end
+      end
+    end
+
+    describe "with eight points" do
+      before do
+        @points = [
+            [0, 1],
+            [1, 0],
+            [3, 4],
+            [4, 3],
+            [7, 8],
+            [8, 7],
+            [8, 9],
+            [9, 8]
+        ]
+      end
+
+      describe "and no separation" do
+        before do
+          @clusterer = Fastcluster::Clusterer.new(0, 0)
+          @points.each do |point|
+            @clusterer << point
+          end
+        end
+
+        it "should return one cluster when no minimum separation is given" do
+          @clusterer.clusters.size.should == 1
+        end
+      end
+
+      describe "and separation 1" do
+        before do
+          @clusterer = Fastcluster::Clusterer.new(1, 0)
+          @points.each do |point|
+            @clusterer << point
+          end
+        end
+
+        it "should have all eight points in individual clusters" do
+          @clusterer.clusters.size.should == 8
+        end
+      end
+
+      describe "and separation 3" do
+        describe "with no resolution limit" do
+          before do
+            @clusterer = Fastcluster::Clusterer.new(3, 0)
+            @points.each do |point|
+              @clusterer << point
+            end
+            @clusters = @clusterer.clusters.sort
+          end
+
+          it "should have three clusters" do
+            @clusters.size.should == 3
+          end
+
+          it "should have clusters size 2, 2, and 4 " do
+            @clusters[0].size.should == 2
+            @clusters[1].size.should == 2
+            @clusters[2].size.should == 4
+          end
+        end
+
+        describe "with coarse resolution" do
+          before do
+            @clusterer = Fastcluster::Clusterer.new(3, 5)
+            @points.each do |point|
+              @clusterer << point
+            end
+            @clusters = @clusterer.clusters.sort
+          end
+
+          it "should have three clusters" do
+            @clusters.size.should == 2
+          end
+
+          it "should have clusters size 2, 2, and 4 " do
+            @clusters[0].size.should == 4
+            @clusters[1].size.should == 4
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--format progress
+--loadby mtime
+--reverse
+--debugger

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+require File.dirname(__FILE__) + '/../lib/fastcluster'
+require File.dirname(__FILE__) + '/test_data.rb'

data/spec/test_data.rb

@@ -0,0 +1,28 @@
+POINTS = [[815, 183], [860, 176], [793, 176], [847, 176], [813, 176], [865, 183],
+          [804, 185], [813, 181], [797, 181], [193, 133], [905, 168], [821, 173],
+          [804, 178], [799, 180], [175, 360], [880, 176], [826, 171], [843, 181],
+          [857, 171], [443, 495], [857, 174], [382, 132], [97, 1203], [218, 281],
+          [97, 1778], [814, 181], [474, 133], [797, 179], [844, 180], [812, 178],
+          [846, 18], [795, 183], [862, 182], [840, 175], [788, 176], [478, 140],
+          [860, 173], [974, 16], [833, 181], [288, 130], [831, 874], [884, 174],
+          [834, 179], [836, 182], [181, 354], [346, 46], [855, 171], [855, 180],
+          [959, 177], [792, 181], [138, 1774], [283, 783], [815, 877], [807, 178],
+          [430, 497], [819, 181], [801, 176], [836, 182], [825, 176], [873, 179],
+          [847, 182], [124, 1678], [157, 132], [835, 177], [827, 180], [532, 1191],
+          [873, 178], [174, 128], [805, 1328], [798, 178], [502, 659], [804, 180],
+          [960, 178], [886, 182], [867, 183], [875, 179], [854, 176], [849, 185],
+          [136, 1783], [800, 181], [810, 180], [312, 782], [865, 177], [745, 125],
+          [833, 178], [882, 181], [834, 177], [821, 184], [899, 182], [26, 124],
+          [859, 182], [892, 174], [172, 134], [822, 182], [396, 135], [830, 184],
+          [792, 185], [427, 488], [818, 173], [832, 177], [406, 129], [852, 181],
+          [805, 177], [820, 175], [19, 14], [839, 183], [264, 127], [800, 172],
+          [811, 176], [827, 178], [896, 177], [863, 183], [813, 177], [458, 495],
+          [808, 181], [850, 748], [810, 184], [850, 181], [886, 179], [446, 497],
+          [851, 180], [592, 132], [300, 538], [794, 180], [815, 180], [57, 1772],
+          [799, 175], [821, 182], [135, 1681], [830, 483], [796, 173], [887, 40],
+          [823, 179], [864, 179], [322, 30], [886, 182], [808, 178], [823, 189],
+          [230, 360], [224, 275], [875, 179], [133, 1773], [844, 175], [433, 495],
+          [13, 15], [856, 178], [871, 181], [658, 130], [839, 183], [822, 83],
+          [827, 175], [848, 179], [894, 184], [833, 177], [828, 176], [482, 135],
+          [841, 177], [817, 184], [470, 140], [800, 180], [857, 15], [807, 187],
+          [425, 497], [64, 131], [852, 580], [883, 183], [836, 181], [878, 177]]

data/test.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/lib/fastcluster'
+require 'benchmark'
+
+points = [[815, 183], [860, 176], [793, 176], [847, 176], [813, 176], [865, 183],
+          [804, 185], [813, 181], [797, 181], [193, 133], [905, 168], [821, 173],
+          [804, 178], [799, 180], [175, 360], [880, 176], [826, 171], [843, 181],
+          [857, 171], [443, 495], [857, 174], [382, 132], [97, 1203], [218, 281],
+          [97, 1778], [814, 181], [474, 133], [797, 179], [844, 180], [812, 178],
+          [846, 18], [795, 183], [862, 182], [840, 175], [788, 176], [478, 140],
+          [860, 173], [974, 16], [833, 181], [288, 130], [831, 874], [884, 174],
+          [834, 179], [836, 182], [181, 354], [346, 46], [855, 171], [855, 180],
+          [959, 177], [792, 181], [138, 1774], [283, 783], [815, 877], [807, 178],
+          [430, 497], [819, 181], [801, 176], [836, 182], [825, 176], [873, 179],
+          [847, 182], [124, 1678], [157, 132], [835, 177], [827, 180], [532, 1191],
+          [873, 178], [174, 128], [805, 1328], [798, 178], [502, 659], [804, 180],
+          [960, 178], [886, 182], [867, 183], [875, 179], [854, 176], [849, 185],
+          [136, 1783], [800, 181], [810, 180], [312, 782], [865, 177], [745, 125],
+          [833, 178], [882, 181], [834, 177], [821, 184], [899, 182], [26, 124],
+          [859, 182], [892, 174], [172, 134], [822, 182], [396, 135], [830, 184],
+          [792, 185], [427, 488], [818, 173], [832, 177], [406, 129], [852, 181],
+          [805, 177], [820, 175], [19, 14], [839, 183], [264, 127], [800, 172],
+          [811, 176], [827, 178], [896, 177], [863, 183], [813, 177], [458, 495],
+          [808, 181], [850, 748], [810, 184], [850, 181], [886, 179], [446, 497],
+          [851, 180], [592, 132], [300, 538], [794, 180], [815, 180], [57, 1772],
+          [799, 175], [821, 182], [135, 1681], [830, 483], [796, 173], [887, 40],
+          [823, 179], [864, 179], [322, 30], [886, 182], [808, 178], [823, 189],
+          [230, 360], [224, 275], [875, 179], [133, 1773], [844, 175], [433, 495],
+          [13, 15], [856, 178], [871, 181], [658, 130], [839, 183], [822, 83],
+          [827, 175], [848, 179], [894, 184], [833, 177], [828, 176], [482, 135],
+          [841, 177], [817, 184], [470, 140], [800, 180], [857, 15], [807, 187],
+          [425, 497], [64, 131], [852, 580], [883, 183], [836, 181], [878, 177],
+          [815, 183], [860, 176], [793, 176], [847, 176], [813, 176], [865, 183],
+          [804, 185], [813, 181], [797, 181], [193, 133], [905, 168], [821, 173],
+          [804, 178], [799, 180], [175, 360], [880, 176], [826, 171], [843, 181],
+          [857, 171], [443, 495], [857, 174], [382, 132], [97, 1203], [218, 281],
+          [97, 1778], [814, 181], [474, 133], [797, 179], [844, 180], [812, 178],
+          [846, 18], [795, 183], [862, 182], [840, 175], [788, 176], [478, 140],
+          [860, 173], [974, 16], [833, 181], [288, 130], [831, 874], [884, 174],
+          [834, 179], [836, 182], [181, 354], [346, 46], [855, 171], [855, 180],
+          [959, 177], [792, 181], [138, 1774], [283, 783], [815, 877], [807, 178],
+          [430, 497], [819, 181], [801, 176], [836, 182], [825, 176], [873, 179],
+          [847, 182], [124, 1678], [157, 132], [835, 177], [827, 180], [532, 1191],
+          [873, 178], [174, 128], [805, 1328], [798, 178], [502, 659], [804, 180],
+          [960, 178], [886, 182], [867, 183], [875, 179], [854, 176], [849, 185],
+          [136, 1783], [800, 181], [810, 180], [312, 782], [865, 177], [745, 125],
+          [833, 178], [882, 181], [834, 177], [821, 184], [899, 182], [26, 124],
+          [859, 182], [892, 174], [172, 134], [822, 182], [396, 135], [830, 184],
+          [792, 185], [427, 488], [818, 173], [832, 177], [406, 129], [852, 181],
+          [805, 177], [820, 175], [19, 14], [839, 183], [264, 127], [800, 172],
+          [811, 176], [827, 178], [896, 177], [863, 183], [813, 177], [458, 495],
+          [808, 181], [850, 748], [810, 184], [850, 181], [886, 179], [446, 497],
+          [851, 180], [592, 132], [300, 538], [794, 180], [815, 180], [57, 1772],
+          [799, 175], [821, 182], [135, 1681], [830, 483], [796, 173], [887, 40],
+          [823, 179], [864, 179], [322, 30], [886, 182], [808, 178], [823, 189],
+          [230, 360], [224, 275], [875, 179], [133, 1773], [844, 175], [433, 495],
+          [13, 15], [856, 178], [871, 181], [658, 130], [839, 183], [822, 83],
+          [827, 175], [848, 179], [894, 184], [833, 177], [828, 176], [482, 135],
+          [841, 177], [817, 184], [470, 140], [800, 180], [857, 15], [807, 187],
+          [425, 497], [64, 131], [852, 580], [883, 183], [836, 181], [878, 177]]
+
+puts Benchmark.measure {
+clusterer = Fastcluster::Clusterer.new(105, 5, points)
+clusters = clusterer.clusters 
+
+clusters.sort{|a,b| a.size == b.size ? a.x <=> b.x : a.size <=> b.size }.each do |cluster|
+  puts cluster
+end
+
+}

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: fastcluster
+version: !ruby/object:Gem::Version 
+  version: "0.9"
+platform: ruby
+authors: 
+- Jeremy Wells
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-24 00:00:00 +13:00
+default_executable: 
+dependencies: []
+
+description: A clustering library for 2 dimensional points
+email: jeremy@boost.co.nz
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- CHANGELOG
+- README.rdoc
+- ext/clusterer.c
+- ext/extconf.rb
+- lib/fastcluster.rb
+- lib/fastcluster/cluster.rb
+files: 
+- CHANGELOG
+- Manifest
+- README.rdoc
+- Rakefile
+- ext/clusterer.c
+- ext/extconf.rb
+- lib/fastcluster.rb
+- lib/fastcluster/cluster.rb
+- spec/lib/fastcluster/cluster_spec.rb
+- spec/lib/fastcluster/clusterer_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/test_data.rb
+- test.rb
+- fastcluster.gemspec
+has_rdoc: true
+homepage: http://github.com/jemmyw/fastcluster
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Fastcluster
+- --main
+- README.rdoc
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: fastcluster
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A clustering library for 2 dimensional points
+test_files: []
+