cluda 0.0.1

data/lib/cluda/distances/chebyshev.rb

@@ -0,0 +1,10 @@
+module Cluda
+  class Chebyshev <  Distance
+    
+    def self.distance(x0, x)
+      validate( [x0,x] )
+
+      [ (x0[:x] - x[:x]).abs, (x0[:y] - x[:y]).abs ].max
+    end
+  end
+end

data/lib/cluda/distances/distance.rb

@@ -0,0 +1,24 @@
+module Cluda
+  class InvalidPoint < RuntimeError; end
+  
+  class Distance 
+    extend Math
+    
+    def self.distance(x0, x)
+      raise ::NotImplementedError.new("You must implement distance method")
+    end
+
+    protected
+
+    def self.validate( data )
+      points = data.is_a?(Array) ? data : [ data ]  
+      points.each do |point|
+        raise InvalidPoint unless  point.is_a?(Hash) &&  
+                                   point.include?(:x) && point.include?(:y) &&
+                                   point[:x].is_a?(Numeric) && point[:y].is_a?(Numeric)
+      end
+
+      points 
+    end
+  end
+end

data/lib/cluda/distances/euclidean.rb

@@ -0,0 +1,10 @@
+module Cluda
+  class Euclidean <  Distance
+    
+    def self.distance(x0, x)
+      validate( [x0,x] )
+
+      sqrt( (x0[:x] - x[:x]) ** 2 + (x0[:y] - x[:y]) ** 2 )
+    end
+  end
+end

data/lib/cluda/distances/manhattan.rb

@@ -0,0 +1,10 @@
+module Cluda
+  class Manhattan <  Distance
+    
+    def self.distance(x0, x)
+      validate( [x0,x] )
+
+      (x0[:x] - x[:x]).abs + (x0[:y] - x[:y]).abs
+    end
+  end
+end

data/lib/cluda/kmeans.rb

@@ -0,0 +1,95 @@
+require 'cluda/distances/manhattan'
+require 'cluda/distances/euclidean'
+require 'cluda/distances/chebyshev'
+
+module Cluda
+  class InvalidDistanceMethod < RuntimeError; end
+
+  class Kmeans
+    def self.classify( list, k, class_name = 'euclidean', max_iterations = 50 )
+      raise InvalidDistanceMethod unless valid_class?(class_name)
+      
+      _class = Cluda.const_get( class_name.downcase.capitalize )
+      _class.validate( list )
+
+      iter = 1
+      previous_centroids = nil
+      centroids = initialize_centroids( list , k, _class )
+
+      while (iter < max_iterations) && (previous_centroids != centroids)
+        output = init_output(centroids)
+        
+        list.each do |point|
+          output[nearest_centroid(point, centroids, _class)] << point
+        end
+
+        iter += 1
+        previous_centroids = centroids
+        centroids = move_centroids( output )
+      end
+
+      output
+    end
+
+    protected 
+
+    def self.nearest_centroid(point, centroids, _class = Cluda::Euclidean )
+      return nil if centroids.empty?
+      
+      _class.validate( point )
+      
+      nearest_centroid = centroids[0]
+      min_distance = _class.distance(point, nearest_centroid)
+
+      centroids.each do |centroid|
+        new_distance = _class.distance(point, centroid)
+        if new_distance < min_distance
+          min_distance = new_distance
+          nearest_centroid = centroid
+        end
+      end
+
+      nearest_centroid
+    end
+
+    def self.initialize_centroids( list , k, _class = Cluda::Euclidean )
+      _class.validate( list )
+
+      return [] if list.empty? || k > list.size
+
+      list.shuffle( random: Random.new.rand(0...k) )[0...k]
+    end
+
+    private 
+
+    def self.valid_class?( name )
+      ['euclidean', 'chebyshev', 'manhattan'].include?( name.downcase )
+    end
+
+    def self.init_output(centroids) 
+      centroids.each_with_object({}) do |centroid, memo|
+        memo[centroid] = []
+      end
+    end
+
+    def self.median( list )
+      sorted_list = list.sort
+      len = list.size
+
+      sorted_list[( (len / 2 ) + 0.5 ).floor]
+    end
+
+    def self.get_key_values( points, key )
+      points.map { |point| point[key] }
+    end
+    
+    def self.move_centroids( output )
+      output.map do |(key, value)|
+        x = median( get_key_values(value, :x) )
+        y = median( get_key_values(value, :y) )
+        
+        { x: x, y: y }
+      end
+    end
+  end
+end

data/lib/cluda.rb

@@ -0,0 +1,4 @@
+$:.unshift File.expand_path('..', __FILE__ )
+
+require 'cluda/distances/distance'
+require 'cluda/kmeans' 

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: cluda
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Enrique Figuerola
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: CLustering Data Analysis gem
+email: hard_rock15@msn.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cluda.rb
+- lib/cluda/kmeans.rb
+- lib/cluda/distances/distance.rb
+- lib/cluda/distances/euclidean.rb
+- lib/cluda/distances/manhattan.rb
+- lib/cluda/distances/chebyshev.rb
+homepage: https://github.com/emfigo/cluda
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: CLuDA
+test_files: []