clusterable 0.0.1

data/lib/clusterable.rb

@@ -0,0 +1,7 @@
+module Clusterable
+  
+  VERSION = '0.0.1'
+  
+  autoload :Point,   'clusterable/point'
+  autoload :Cluster, 'clusterable/cluster'
+end

data/lib/clusterable/cluster.rb

@@ -0,0 +1,85 @@
+module Clusterable
+  class Cluster
+    attr_accessor :points, :center
+    
+    def initialize(points = [], center = nil)
+      raise "can't initialize an empty cluster" unless points.size > 0
+      self.points = points
+      self.center = center || calculate_center
+    end
+    
+    # See: http://en.wikipedia.org/wiki/K-means_clustering
+    def self.kmeans(points, sample_size, distance_cutoff)
+      initial  = pick_random(points, sample_size)
+      clusters = initial.map do |point|
+                   new([point], point) 
+                 end
+      
+      while true
+        lists = []
+        clusters.each { lists << [] }
+        
+        points.each do |point|
+          smallest_distance = point.distance_to(clusters.first.center)
+          index = 0
+          
+          clusters[1..clusters.length].each.with_index do |cluster, i|
+            distance = point.distance_to(cluster.center)
+            
+            if distance < smallest_distance
+              smalles_distance = distance
+              index = i + 1
+            end
+          end
+          
+          lists[index] << point
+        end
+        
+        biggest_shift = 0.0
+        clusters.each.with_index do |cluster, index|
+          if lists[index].size > 0
+            shift = cluster.update(lists[index])
+            biggest_shift = [shift, biggest_shift].max
+          end
+        end
+        
+        break if biggest_shift < distance_cutoff
+      end
+      
+      clusters
+    end
+    
+    def update(points)
+      self.points = points.compact
+      old_center  = center.dup
+      self.center = calculate_center
+      
+      center.distance_to(old_center)
+    end
+    
+    private
+    
+    # This random array picker should be optimized for speed,
+    # but this is untested. 
+    def self.pick_random(array, number_of_items)
+      size    = array.size
+      indexes = []
+      
+      number_of_items.times do
+        random = rand(size) while random.nil? || indexes.include?(random)
+        indexes << random
+      end
+      
+      indexes.map do |index|
+        array[index]
+      end
+    end
+    
+    def calculate_center
+      latitude  = points.inject(0.0) { |sum, point| sum + point.latitude  } / points.length
+      longitude = points.inject(0.0) { |sum, point| sum + point.longitude } / points.length
+      
+      Point.new(latitude, longitude)
+    end
+  end
+end

data/lib/clusterable/point.rb

@@ -0,0 +1,27 @@
+module Clusterable
+  class Point < Hash
+    def initialize(latitude, longitude)
+      self[:latitude]  = latitude
+      self[:longitude] = longitude
+    end
+    
+    def latitude
+      self[:latitude]
+    end
+    
+    def longitude
+      self[:longitude]
+    end
+    
+    def distance_to(target)
+      Math.sqrt(
+        ((latitude  - target.latitude ) ** 2) +
+        ((longitude - target.longitude) ** 2)
+      )
+    end
+    
+    def to_s
+      [latitude, longitude].join(", ")
+    end
+  end
+end

data/spec/lib/clusterable/cluster_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Clusterable::Cluster do
+  def random_point(lat = nil, lng = nil)
+    Clusterable::Point.new(lat || 50.9985319,
+                           lng ||  5.8573735)
+  end
+  
+  describe 'instance methods' do
+    describe '#initialize' do
+      it 'returns a cluster' do
+        Clusterable::Cluster.new([random_point]).should be_an_instance_of(Clusterable::Cluster)
+      end
+      
+      it 'requires at least 1 point' do
+        lambda {
+          Clusterable::Cluster.new([])
+        }.should raise_error
+      end
+      
+      it 'sets the points attribute' do
+        points  = [random_point]
+        cluster = Clusterable::Cluster.new(points)
+        
+        cluster.points.should eql(points)
+      end
+      
+      it 'accepts an optional center point' do
+        lambda {
+          Clusterable::Cluster.new([random_point], random_point)
+        }.should_not raise_error
+      end
+      
+      it 'sets the center attribute to the specified center point' do
+        center  = random_point
+        cluster = Clusterable::Cluster.new([random_point], center)
+        cluster.center.should eql(center)
+      end
+      
+      it 'calculates the center point if unspecified' do
+        points  = [random_point(50, 5), random_point(60, 10)]
+        cluster = Clusterable::Cluster.new(points)
+        
+        cluster.center.should_not be_nil
+        cluster.center.latitude.should  eql(55.0)
+        cluster.center.longitude.should eql(7.5)
+      end
+    end
+    
+    describe '#update' do
+      let(:cluster) { Clusterable::Cluster.new([random_point]) }
+      let(:target)  { Clusterable::Point.new(50.8889999, 5.9773202) }
+      
+      it 'overwrites the points attribute' do
+        points = [target]
+        cluster.update(points)
+        
+        cluster.points.should eql(points)
+      end
+      
+      it 'recalculates the center point' do
+        points = [random_point(50, 5)]
+        cluster.update(points)
+        
+        cluster.center.latitude.should  eql(50.0)
+        cluster.center.longitude.should eql(5.0)
+      end
+      
+      it 'returns the distance from the old center to the new center' do
+        cluster.update([target]).should eql(0.16243297037513815)
+      end
+    end
+  end
+end

data/spec/lib/clusterable/point_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Clusterable::Point do
+  describe 'instance methods' do
+    let(:marker) { Clusterable::Point.new(50.9985319, 5.8573735) }
+    
+    describe '#initialize' do
+      let(:marker) { Clusterable::Point.new('latitude', 'longitude') }
+      
+      it 'sets the latitude' do
+        marker[:latitude].should eql('latitude')
+      end
+      
+      it 'sets the longitude' do
+        marker[:longitude].should eql('longitude')
+      end
+    end
+    
+    describe '#latitude' do
+      it 'returns the latitude' do
+        marker.latitude.should eql(marker[:latitude])
+      end
+    end
+    
+    describe '#longitude' do
+      it 'returns the longitude' do
+        marker.longitude.should eql(marker[:longitude])
+      end
+    end
+    
+    describe '#distance_to' do
+      let(:target) { Clusterable::Point.new(50.8889999, 5.9773202) }
+      
+      it 'returns the distance to another point' do
+        marker.distance_to(marker).should eql(0.0)
+        marker.distance_to(target).should eql(0.16243297037513815)
+      end
+    end
+    
+    describe '#to_s' do
+      it 'returns the point as a string' do
+        marker.to_s.should eql('50.9985319, 5.8573735')
+      end
+    end
+  end
+end

data/spec/lib/clusterable_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Clusterable do
+  describe 'VERSION' do
+    it "is a valid semantic version" do
+      Clusterable::VERSION.should match(/^[0-9]+\.[0-9]+\.[0-9]+([a-zA-Z]([0-9A-Za-z-]+)?)?$/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'clusterable'
+require 'rspec'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: clusterable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tom-Eric Gerritsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-27 00:00:00.000000000 Z
+dependencies: []
+description: Create clusters of points.
+email:
+- tomeric@eet.nu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- benchmark/benchmark.rb
+- benchmark/points.csv
+- lib/clusterable/cluster.rb
+- lib/clusterable/point.rb
+- lib/clusterable.rb
+- spec/lib/clusterable/cluster_spec.rb
+- spec/lib/clusterable/point_spec.rb
+- spec/lib/clusterable_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+- Rakefile
+- Gemfile
+- README.md
+homepage: http://github.com/eet-nu/clusterable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2152434804067564302
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2152434804067564302
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Create clusters of points.
+test_files: []