cluda 0.0.2 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84fc5617e8ce06d8b83eec5c0e6bfc1ea7cf1c43246f5040078324cf754089c7
+  data.tar.gz: 812430fa9d168cdd552b059ffaa2933e930a3d461d28d9e2991a36bf1e44a42c
+SHA512:
+  metadata.gz: ff054734dc37f4a806dc3a2635e26eec634138abd6a1ceca982b6c54bc6910be36b2ccf00b5be6d7636e56ebf82b6ca122db783f8529ed8f972fdb3b944c10dd
+  data.tar.gz: b9e3fd5d71c2db328303288e17991cd892912f24e85fef0c3f0555a0bd06d42a35bb48ee609423b829f10aa015756946136052cd7fb8c04f5f0e0b67010b8ed0

data/lib/cluda.rb

@@ -1,5 +1,7 @@
-$:.unshift File.expand_path('..', __FILE__ )
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path(__dir__)
 
 require 'cluda/distances/distance'
 require 'cluda/cluda_common'
-require 'cluda/kmeans' 
+require 'cluda/kmeans'

data/lib/cluda/cluda_common.rb

@@ -1,79 +1,78 @@
+# frozen_string_literal: true
+
 module Cluda
+  module_function
+
   class InvalidPoint < RuntimeError; end
   class InvalidCentroid < RuntimeError; end
   class InvalidSmartPoint < RuntimeError; end
   class InvalidDistanceMethod < RuntimeError; end
-  
+
   # For an output given by CluDA calculate the means for each centroid
   #
-  #Example:
+  # Example:
   #  > clusters = {{:x=>2, :y=>2}=>
   #                           [{:x=>1, :y=>1, :distance=>1.4142135623730951},
   #                            {:x=>2, :y=>1, :distance=>1.0},
   #                            {:x=>1, :y=>2, :distance=>1.0},
   #                            {:x=>2, :y=>2, :distance=>0.0}]}
   #  > Cluda.median_for_centroids(clusters)
-  #Arguments:
+  # Arguments:
   #   points:            ( Hash )
-  def self.median_for_centroids ( points )
-    points.keys.each do | centroid |
-      validate_smart_points(  points[centroid] )
+  def median_for_centroids(points)
+    points.each_key do |centroid|
+      validate_smart_points(points[centroid])
     end
 
     points.keys.map do |centroid|
-      centroid.merge( median: median_for_centroid( centroid, points ) )
+      centroid.merge(median: median_for_centroid(centroid, points))
     end
   end
-  
-  protected
-  
-  def self.valid_class?( name )
-    ['euclidean', 'chebyshev', 'manhattan'].include?( name.downcase )
+
+  def valid_class?(name)
+    %w[euclidean chebyshev manhattan].include?(name.downcase)
   end
 
-  def self.validate_centroids( centroids )
-    centroids = centroids.is_a?(Array) ? centroids : [ centroids ]  
-    
+  def validate_centroids(centroids)
+    centroids = centroids.is_a?(Array) ? centroids : [centroids]
+
     validate(centroids)
-   
+
     centroids.each do |point|
-      raise InvalidCentroid unless  point.include?(:median)
+      raise InvalidCentroid unless point.include?(:median)
     end
 
     centroids
   end
-  
-  def self.validate_smart_points( points )
-    points = points.is_a?(Array) ? points : [ points ]  
-    
-    validate( points )
-   
+
+  def validate_smart_points(points)
+    points = points.is_a?(Array) ? points : [points]
+
+    validate(points)
+
     points.each do |point|
-      raise InvalidSmartPoint unless  point.include?(:distance)
+      raise InvalidSmartPoint unless point.include?(:distance)
     end
 
     points
   end
-  
-  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 
+  def validate(data)
+    data = [data] unless data.is_a?(Array)
+
+    data.each do |point|
+      raise InvalidPoint unless point.is_a?(Hash) && point[:x].is_a?(Numeric) && point[:y].is_a?(Numeric)
+    end
   end
 
-  def self.median_for_centroid( centroid, points )
-    median( points[centroid].map{ |point| point[:distance] } )
+  def median_for_centroid(centroid, points)
+    median(points[centroid].map { |point| point[:distance] })
   end
 
-  def self.median( list )
+  def median(list)
     sorted_list = list.sort
     len = list.size
 
-    sorted_list[( (len / 2 ) + 0.5 ).floor]
+    sorted_list[((len / 2) + 0.5).floor]
   end
 end

data/lib/cluda/distances/chebyshev.rb

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

data/lib/cluda/distances/distance.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Cluda
-  class Distance 
+  class Distance
     extend Math
-    
-    def self.distance(x0, x)
-      raise ::NotImplementedError.new("You must implement distance method")
+
+    def self.distance(_x0, _x)
+      raise ::NotImplementedError, 'You must implement distance method'
     end
   end
 end

data/lib/cluda/distances/euclidean.rb

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

data/lib/cluda/distances/manhattan.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Cluda
-  class Manhattan <  Distance
-    
+  class Manhattan < Distance
     def self.distance(x0, x)
-      Cluda.validate( [x0,x] )
+      Cluda.validate([x0, x])
 
       (x0[:x] - x[:x]).abs + (x0[:y] - x[:y]).abs
     end

data/lib/cluda/kmeans.rb

@@ -1,135 +1,169 @@
+# frozen_string_literal: true
+
 require 'cluda/distances/manhattan'
 require 'cluda/distances/euclidean'
 require 'cluda/distances/chebyshev'
 
 module Cluda
   class Kmeans
-
-    DEFAULT_OPTS = { k: 1, 
-                     centroids: nil, 
-                     distance_method: 'euclidean', 
+    DEFAULT_OPTS = { k: 1,
+                     centroids: nil,
+                     distance_method: 'euclidean',
                      be_smart: false,
                      margin_distance_percentage: 0,
-                     max_iterations: 50 }
-
-    #Classify the points using KMeans as the clustering algorithm
-    #
-    #Example:
-    #   >> points = [ { x: 1, y: 1}, { x: 2, y: 1}, { x: 1, y: 2}, { x: 2, y: 2}, { x: 4, y: 6}, { x: 5, y: 7}, { x: 5, y: 6}, { x: 5, y: 5}, { x: 6, y: 6}, { x: 6, y: 5}]
-    #   >> Cluda::Kmeans.classify( points, k: 1, distance_method: 'euclidean', be_smart: true, max_iterations: 50)
-    #Arguments:
-    #   list:                       (Array [Hash] )
-    #   k:                          (Numeric) *optional*
-    #   centroids:                  (Array) *optional*
-    #   distance_method:            (String) *optional*
-    #   be_smart:                   (Boolean) *optional* [If you want CluDA to be smart you have to specify the centroids ]
-    #   margin_distance_percentage: (Numeric) *optional* [Between 0 and 1]
-    #   max_iterations:             (Numeric) *optional*
-    def self.classify( list, opts = {} )
-      @opts = DEFAULT_OPTS.merge(opts)
-      
-      raise Cluda::InvalidDistanceMethod unless Cluda::valid_class?(@opts[:distance_method])
-     
-      _class = Cluda.const_get( @opts[:distance_method].downcase.capitalize )
-      
-      Cluda.validate( list ) 
-      Cluda.validate_centroids( @opts[:centroids] ) if @opts[:be_smart] 
-
-      iter = 1
-      max_iterations             = @opts[:max_iterations]
-      centroids                  = @opts[:centroids].nil? || @opts[:centroids].empty? ? initialize_centroids( list , @opts[:k]) : process_centroids( @opts[:centroids] )
-      previous_centroids         = nil
-      smart_clustering           = @opts[:be_smart]
-      margin_distance_percentage = @opts[:margin_distance_percentage]
-
-      while (iter < max_iterations) && (previous_centroids != centroids)
-        output = init_output(centroids)
-        margin = smart_clustering ? @median_centroid * margin_distance_percentage : 0
-
-        list.each do |point|
-          centroid, distance = nearest_centroid(point, centroids, _class)
-          
-          if smart_clustering && distance > ( @median_centroid + margin )
-            @median_centroid = distance
-            centroids << point
-            create_centroid(point, output)
-            centroid = point
-            distance = 0
+                     max_iterations: 50 }.freeze
+
+    class << self
+      # Classify the points using KMeans as the clustering algorithm
+      #
+      # Example:
+      #   >> points = [
+      #   { x: 1, y: 1},
+      #   { x: 2, y: 1},
+      #   { x: 1, y: 2},
+      #   { x: 2, y: 2},
+      #   { x: 4, y: 6},
+      #   { x: 5, y: 7},
+      #   { x: 5, y: 6},
+      #   { x: 5, y: 5},
+      #   { x: 6, y: 6},
+      #   { x: 6, y: 5}
+      #   ]
+      #   >> Cluda::Kmeans.classify( points, k: 1, distance_method: 'euclidean', be_smart: true, max_iterations: 50)
+      # Arguments:
+      #   list:                       (Array [Hash] )
+      #   k:                          (Numeric) *optional*
+      #   centroids:                  (Array) *optional*
+      #   distance_method:            (String) *optional*
+      #   [If you want CluDA to be smart you have to specify the centroids ]
+      #   be_smart:                   (Boolean) *optional*
+      #   margin_distance_percentage: (Numeric) *optional* [Between 0 and 1]
+      #   max_iterations:             (Numeric) *optional*
+      def classify(list, opts = {})
+        Cluda.validate(list)
+        Cluda.validate_centroids(opts[:centroids]) if opts[:be_smart]
+
+        config = generate_config(list, opts)
+
+        raise Cluda::InvalidDistanceMethod unless Cluda.valid_class?(config[:distance_method])
+
+        calculate_clusters(list, **config)
+      end
+
+      def generate_config(list, opts)
+        config = DEFAULT_OPTS.merge(opts)
+
+        centroids_present?(config) ? process_centroids(config) : initialize_centroids(list, config)
+
+        config[:margin] = config[:be_smart] ? config[:median_centroid] * config[:margin_distance_percentage] : 0
+
+        config
+      end
+
+      def process_centroids(config)
+        config[:centroids].each do |point|
+          if config[:median_centroid].nil? || config[:median_centroid] < point[:median]
+            config[:median_centroid] = point[:median]
           end
 
-          output[centroid] << point.merge( distance: distance )
+          point.delete_if { |k, _| !%i[x y].include? k }
         end
 
-        iter += 1
-        previous_centroids = centroids
-        centroids = move_centroids( output )
+        config
       end
 
-      output
-    end
+      def initialize_centroids(list, config)
+        return config if list.empty? || config[:k] > list.size
+
+        config[:centroids] = list.shuffle(random: Random.new(rand(0...config[:k])))[0...config[:k]]
+
+        config
+      end
+
+      def nearest_centroid(point, centroids, klass = Cluda::Euclidean)
+        return nil if centroids.empty?
+
+        Cluda.validate(point)
 
-    protected 
-
-    def self.nearest_centroid(point, centroids, _class = Cluda::Euclidean )
-      return nil if centroids.empty?
-      
-      Cluda.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
+        nearest_centroid = centroids[0]
+        min_distance = klass.distance(point, nearest_centroid)
+
+        centroids.each do |centroid|
+          new_distance = klass.distance(point, centroid)
+          if new_distance < min_distance
+            min_distance = new_distance
+            nearest_centroid = centroid
+          end
         end
+
+        [nearest_centroid, min_distance]
       end
 
-      [nearest_centroid, min_distance]
-    end
+      private
 
-    def self.initialize_centroids( list , k )
-      Cluda.validate( list )
+      def calculate_clusters(list, centroids:, distance_method:, **config)
+        cluster = {}
 
-      return [] if list.empty? || k > list.size
+        previous_centroids = nil
+        klass = Cluda.const_get(distance_method.downcase.capitalize)
 
-      list.shuffle( random: Random.new.rand(0...k) )[0...k]
-    end
+        config[:max_iterations].times do
+          break if previous_centroids == centroids
 
-    private 
+          cluster = assign_points_to_centroids(list, centroids, klass, config)
 
-    def self.init_output(centroids) 
-      centroids.each_with_object({}) do |centroid, memo|
-        memo[centroid] = []
+          previous_centroids = centroids
+          centroids = move_centroids(cluster)
+        end
+
+        cluster
       end
-    end
 
-    def self.create_centroid( centroid, output )
-      output[centroid] = []
-    end
+      def centroids_present?(opts)
+        !(opts[:centroids].nil? || opts[:centroids].empty?)
+      end
+
+      def init_cluster(centroids)
+        centroids.each_with_object({}) do |centroid, memo|
+          memo[centroid] = []
+        end
+      end
 
-    def self.process_centroids(centroids)
-      centroids.each_with_object([]) do |point, memo|
-        @median_centroid = point[:median] if @median_centroid.nil?  || @median_centroid < point[:median]
-          
-        memo << { x: point[:x], y: point[:y] }
+      def create_centroid(centroid, output)
+        output[centroid] = []
       end
-    end
 
-    def self.get_key_values( points, key )
-      points.map { |point| point[key] }
-    end
-    
-    def self.move_centroids( output )
-      output.map do |(key, value)|
-        unless value.empty?
-          x = Cluda.median( get_key_values(value, :x) )
-          y = Cluda.median( get_key_values(value, :y) )
-        
+      def get_key_values(points, key)
+        points.map { |point| point[key] }
+      end
+
+      def move_centroids(output)
+        output.map do |(_key, value)|
+          next if value.empty?
+
+          x = Cluda.median(get_key_values(value, :x))
+          y = Cluda.median(get_key_values(value, :y))
+
           { x: x, y: y }
+        end.compact
+      end
+
+      def assign_points_to_centroids(list, centroids, klass, config)
+        list.each_with_object({}) do |point, cluster|
+          centroid, distance = nearest_centroid(point, centroids, klass)
+
+          if config[:be_smart] && distance > (config[:median_centroid] + config[:margin])
+            config[:median_centroid] = distance
+            centroids << point
+            create_centroid(point, cluster)
+            centroid = point
+            distance = 0
+          end
+
+          cluster[centroid] ||= []
+          cluster[centroid] << point.merge(distance: distance)
         end
-      end.compact
+      end
     end
   end
 end

data/lib/cluda/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Cluda
+  VERSION = '0.1.0'
+end

metadata

@@ -1,84 +1,92 @@
 --- !ruby/object:Gem::Specification
 name: cluda
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
-- Enrique Figuerola
+- Enrique M Figuerola Gomez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-06 00:00:00.000000000 Z
+date: 2020-03-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.11.0
+        version: '3.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.11.0
+        version: '3.8'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.70'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.70'
 description: CLustering Data Analysis gem
-email: hard_rock15@msn.com
+email: me@emfigo.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/cluda.rb
 - lib/cluda/cluda_common.rb
-- lib/cluda/kmeans.rb
+- lib/cluda/distances/chebyshev.rb
 - lib/cluda/distances/distance.rb
 - lib/cluda/distances/euclidean.rb
 - lib/cluda/distances/manhattan.rb
-- lib/cluda/distances/chebyshev.rb
+- lib/cluda/kmeans.rb
+- lib/cluda/version.rb
 homepage: https://github.com/emfigo/cluda
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 3.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: CLuDA
 test_files: []