davidrichards-kmeans 0.0.3

data/README.rdoc

@@ -0,0 +1,33 @@
+== KMeans
+
+This is another KMeans implementation.  I have a few things that I need to work on:
+
+* Extract the NodeList information out of the Node to make it more flexible
+* Work on an online version of this code
+
+The basic idea is that I wanted to solve a problem for a client, but I didn't want to throw the code away.  So you get this.
+
+==Usage
+
+For now, a very quick demonstration.  This creates a one-dimensional node list with number ranges between 1 and 3, 5, and 6 through 10.  
+
+  @node_list =  (1..100).map { while (n = rand(10) + 1) == 4 or n == 6; end;  n} 
+  @kmeans = KMeans::Agent.call(:k => 3, *@node_list)
+  puts @kmeans.centroids.inspect
+  # => [KMeans::Centroid:[223/26], KMeans::Centroid:[37/17], KMeans::Centroid:[5]]
+  @kmeans.centroids.map {|c| c.position.first.to_f} 
+  # => [8.57692307692308, 2.17647058823529, 5.0]
+
+I'll put a more interesting example together at another time.
+
+==Installation
+
+sudo gem install davidrichards-kmeans
+
+=== Dependencies
+
+* TeguGears
+
+==COPYRIGHT
+
+Copyright (c) 2009 David Richards. See LICENSE for details.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 3

data/bin/kmeans

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby -wKU
+require 'yaml'
+
+version_hash = YAML.load_file(File.join(File.dirname(__FILE__), %w(.. VERSION.yml)))
+version = [version_hash[:major].to_s, version_hash[:minor].to_s, version_hash[:patch].to_s].join(".")
+kmeans_file = File.join(File.dirname(__FILE__), %w(.. lib kmeans))
+config_file = File.join(File.dirname(__FILE__), %w(.. lib include_kmeans))
+
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+require 'optparse'
+options = {:irb => 'irb', :r => ''}
+OptionParser.new do |opt|
+  opt.banner = "Usage: console [environment] [options]"
+  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |v| options[:irb] = v }
+  opt.on("-r=file", 'Require other files') do |v|
+    options[:r] ||= []
+    options[:r] << v
+  end
+  opt.parse!(ARGV)
+end
+
+libs =  " -r irb/completion -r #{kmeans_file} -r #{config_file}"
+r = options[:r]
+r ||= []
+r.each {|f| libs << " -r #{f}"}
+
+puts "Loading KMeans (#{version})"
+
+exec "#{options[:irb]} #{libs} --simple-prompt"

data/lib/ext/enumerable.rb

@@ -0,0 +1,57 @@
+module Enumerable
+  def map_with_index(&block)
+    val = []
+    self.each_with_index { |e, i| val << yield(e, i) }
+    val
+  end
+  
+  def map_with_index!(&block)
+    self.each_with_index do |e, i|
+      val = yield(e, i)
+      self[i] = val
+    end
+  end
+  
+  # Expects an array of scalars
+  def scale_with(ary)
+    val = []
+    self.map_with_index { |e, i| val << e * ary[i] }
+    val
+  end
+  
+  def scale_with!(ary)
+    self.map_with_index! { |e, i| e * ary[i] }
+  end
+  
+  def sum
+    val = any? {|e| e.is_a?(Float)} ? 0.0 : 0
+    self.inject(val) {|s, e| s += e}
+  end
+
+  def average
+    sum/size
+  end
+  alias :mean :average
+  alias :avg :average
+
+  # Returns the position (or first position) of the minimal value.  So, 
+  # [3,2,1,4,5,0].min_position is 5
+  def min_position
+    mp = [nil, nil]
+    each_with_index do |e, i|
+      mp = e, i unless mp.first
+      mp = e, i if e < mp.first
+    end
+    mp.last
+  end
+  
+  def max_position
+    mp = [nil, nil]
+    each_with_index do |e, i|
+      mp = e, i unless mp.first
+      mp = e, i if e > mp.first
+    end
+    mp.last
+  end
+  
+end

data/lib/ext/object.rb

@@ -0,0 +1,16 @@
+class Object
+  
+  # Simpler way to handle a random number between to values
+  def rand_between(a, b)
+    return rand_in_floats(a, b) if a.is_a?(Float) or b.is_a?(Float)
+    range = (a - b).abs + 1
+    rand(range) + [a,b].min
+  end
+  
+  # Handles non-integers
+  def rand_in_floats(a, b)
+    range = (a - b).abs
+    (rand * range) + [a,b].min
+  end
+  
+end

data/lib/include_kmeans.rb

@@ -0,0 +1,2 @@
+# For the IRB client
+include KMeans

data/lib/kmeans.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'tegu_gears'
+
+Dir.glob("#{File.dirname(__FILE__)}/ext/*.rb").each { |file| require file }
+Dir.glob("#{File.dirname(__FILE__)}/kmeans/*.rb").each { |file| require file }
+

data/lib/kmeans/agent.rb

@@ -0,0 +1,83 @@
+module KMeans #:nodoc:
+  class Agent
+    
+    include TeguGears
+
+    class << self
+      # Only works if the agent was processed as an online algorithm
+      def rebase(*node_list)
+        return false unless @@agent
+        @@agent.rebase(*node_list)
+      end
+    end
+    
+    # The number of clusters we're after
+    attr_reader :k
+
+    # Whether we're interested in keeping the results after processing.  To re-process:
+    # Agent.rebase(*new_node_list)
+    attr_reader :online
+    
+    # The centroids used for the clustering
+    attr_reader :centroids
+    
+    # All the affectd nodes
+    def nodes
+      Node.nodes
+    end
+
+    # Example:
+    # KMeans::Agent.call(3, [1,2,1], [2,1,3], ...)
+    # KMeans::Agent.call(:k => 3, :centroids => [[1,2,3],[2,3,4],[3,4,2]], [1,2,1], [2,1,3], ...)
+    def process(opts={}, *node_list)
+      
+      unless self.online
+        Node.clear_nodes! 
+        @centroids = nil
+      end
+      
+      
+      @scaling = opts.fetch(:scaling, false) if opts.is_a?(Hash)
+      Node.add_nodes(*node_list)
+      
+      if opts.is_a?(Hash)
+        @k = opts[:k]
+        @centroids = opts.fetch(:centroids, false)
+        @online = opts.fetch(:online, false)
+      else
+        @k = opts
+      end
+
+      stabilize_centroids
+      @@agent = self if self.online
+      self
+
+    end
+    
+    def rebase(*node_list)
+      Node.add_nodes(*node_list)
+      stabilize_centroids
+      self
+    end
+
+    protected
+    
+      # This is the core algorithm: assign nodes to centroids, rebalance
+      # centroids, repeat until no new assignment is necessary. 
+      def stabilize_centroids
+        @centroids ||= infer_centroids(@k)
+        n = Node.cluster_to(@centroids)
+        while n > 0
+          @centroids.each { |c| c.rebalance }
+          n = Node.cluster_to(@centroids)
+        end
+      end
+      
+      def infer_centroids(k)
+        (1..k).map do
+          Node.random_centroid
+        end
+      end
+    
+  end
+end

data/lib/kmeans/centroid.rb

@@ -0,0 +1,45 @@
+module KMeans #:nodoc:
+  class Centroid
+    
+    # The position of the centroid, or a value for every dimension
+    attr_reader :position
+    
+    def initialize(position)
+      @position = position
+    end
+    
+    def nodes
+      @nodes ||= []
+    end
+    
+    def add_nodes(*new_nodes)
+      new_nodes.each do |node|
+        self.nodes << node
+        node.centroid = self
+      end
+    end
+    alias :add_node :add_nodes
+    
+    def remove_nodes(*nodes)
+      nodes.each do |node|
+        self.nodes.delete(node)
+        node.centroid = nil
+      end
+    end
+    alias :remove_node :remove_nodes
+    
+    # Finds a new centroid based on the nodes currently attached to it
+    def rebalance
+      return true if nodes.empty?
+      size = nodes.first. position.size
+      @position = (0...size).map do |i|
+        self.nodes.map { |e| e. position[i] }.mean
+      end
+    end
+    
+    def inspect
+      "KMeans::Centroid:#{self.position.inspect}"
+    end
+    
+  end
+end

data/lib/kmeans/node.rb

@@ -0,0 +1,126 @@
+module KMeans #:nodoc:
+  class Node
+    class << self
+      
+      # Clears out all nodes.  Don't do this while working on a specific
+      # problem, but in-between problems.  This nodes-on-the-Node stuff needs
+      # to be adjusted when I have some time. 
+      def clear_nodes!
+        self.nodes.clear
+      end
+      
+      # Returns the number of re-assignments made
+      def cluster_to(centroids, scaling=nil)
+        n = 0
+        self.nodes.each do |node|
+          position = centroids.map { |centroid| node.distance(centroid, scaling) }.min_position
+          target_centroid = centroids[position]
+          next if target_centroid == node.centroid
+          node.move_to(target_centroid)
+          n += 1
+        end
+        n
+      end
+      
+      # Gets the max and min on every dimension for every node
+      def find_boundaries
+        return nil if self.nodes.empty?
+        return @@boundaries if @@boundaries
+        # Building this long-hand for good reason...
+        dimensional_array = []
+        self.dimension_size.times {dimensional_array << [nil, nil]}
+        @@boundaries = self.nodes.inject(dimensional_array) do |list, node|
+          node.position.each_with_index do |dimension, i|
+            list[i][0] ||= dimension
+            list[i][1] ||= dimension
+            list[i][0] = dimension if dimension < list[i][0]
+            list[i][1] = dimension if dimension > list[i][1]
+          end
+          list
+        end
+      end
+      alias :boundaries :find_boundaries
+      
+      # A list of nodes initialized
+      def nodes
+        @@nodes ||= []
+      end
+      
+      def dimension_size
+        @@dimension_size
+      end
+      
+      def dimension_size=(val)
+        @@dimension_size = val
+      end
+      
+      # Instantiates the node object and adds them to the list.  Example:
+      # Node.add_nodes [1,2,3], [4,5,3], [2,1,3]
+      # Node.add_nodes *node_list
+      def add_nodes(*nodes)
+        nodes.each do |node|
+          node = new(*node)
+        end
+      end
+      
+      # Adds a node, clears the cache, asserts that the parameter is a node.
+      def add_node(node)
+        node = new(*node) unless node.is_a?(Node)
+        self.dimension_size = node.position.size if self.nodes.empty?
+        raise ArgumentError, "Node does not have the right number of positions" unless
+          node.position.size == self.dimension_size
+        self.nodes << node
+        @@boundaries = nil
+        node
+      end
+      
+      # A centroid that fits between the boundaries on each dimension.  The
+      # boundaries for a 3-dimensional model might look like: 
+      # [[1,5], [0,10], [1,100]]
+      # This means that the first dimension can be between 1 and 5, the second
+      # between 0 and 10, and the third between 1 and 100. 
+      def random_centroid
+        position = (0...self.dimension_size).inject([]) do |list, i|
+          list << rand_between(self.boundaries[i].first, self.boundaries[i].last)
+        end
+        Centroid.new(position)
+      end
+      
+    end
+    
+    # The position on every dimension
+    attr_reader :position
+    
+    # Creates a node based only on the position.  The dimension
+    # cardinality is enforced on the class level (I.e., all nodes must have
+    # the same number of position.) 
+    def initialize(*position)
+      @position = position
+      Node.add_node(self)
+    end
+    
+    # Records which centroid the node is assigned to
+    attr_accessor :centroid
+    
+    def distance(centroid=nil, scaling=nil)
+      centroid ||= self.centroid
+      op = centroid.position
+      map = self.position.map_with_index do |e, i|
+        if scaling
+          (
+            (op[i] * scaling[i]) - 
+            (e * scaling[i])
+          ) ** 2
+        else
+          (op[i] - e) ** 2
+        end
+      end
+      Math.sqrt(map.sum)
+    end
+    
+    def move_to(centroid)
+      self.centroid.remove_node(self) if self.centroid
+      centroid.add_node(self)
+    end
+  end
+end

data/spec/ext/enumerable_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+describe Enumerable do
+  
+  before do 
+    @a = [1,2,3]
+  end
+  
+  it "should have a map_with_index" do
+    @a.map_with_index {|e, i| i * 2}.should eql([0, 2, 4])
+    @a.should eql([1,2,3])
+  end
+  
+  it "should have a destructive map with index" do
+    @a.map_with_index! {|e, i| i * 2}.should eql([0, 2, 4])
+    @a.should eql([0,2,4])
+  end
+  
+  it "should be able to scale an array by another array" do
+    @a.scale_with([2,2,2]).should eql([2,4,6])
+    @a.should eql([1,2,3])
+  end
+
+  it "should have a dextructive scale with method" do
+    @a.scale_with!([2,2,2]).should eql([2,4,6])
+    @a.should eql([2,4,6])
+  end
+  
+  it "should be able to do a simple sum" do
+    @a.sum.should eql(6)
+  end
+  
+  it "should be able to calculate the mean" do
+    @a.mean.should eql(2)
+  end
+
+  it "should know the position of the minimum value" do
+    @a.min_position.should eql(0)
+  end
+  
+  it "should know the position of the maximum value" do
+    @a.max_position.should eql(2)
+  end
+  
+end

data/spec/ext/object_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+describe Object do
+  it "should be able to generate a random number between two integers" do
+    val = (1..100).map {rand_between(1,10)}
+    (val.min >= 1).should be_true
+    (val.max <= 10).should be_true
+  end
+  
+  it "should be able to generate a random number between two floats" do
+    val = (1..100).map {rand_in_floats(1.0,10.0)}
+    (val.min >= 1).should be_true
+    (val.max <= 10).should be_true
+    val.all? {|v| v.should be_is_a(Float)}
+  end
+  
+  it "should be able to work with floats from rand_between" do
+    val = (1..100).map {rand_between(1.0,10.0)}
+    (val.min >= 1).should be_true
+    (val.max <= 10).should be_true
+    val.all? {|v| v.should be_is_a(Float)}
+  end
+end

data/spec/kmeans/agent_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+describe Agent do
+  before(:all) do
+    @node_list = [[1,1,1], [2,2,2], [3,3,3], [7,7,7], [8,8,8],[9,9,9]]
+  end
+  
+  it "should be able to process things simply" do
+    agent = Agent.process(:k => 2, *@node_list)
+    centroid_map = agent.centroids.map {|c| c.position}
+    centroid_map.should be_include([2,2,2])
+    centroid_map.should be_include([8,8,8])
+  end
+  
+  it "should be able to assume the first parameter is the k parameter in a simple usage situation" do
+    agent = Agent.process(2, *@node_list)
+    centroid_map = agent.centroids.map {|c| c.position}
+    centroid_map.should be_include([2,2,2])
+    centroid_map.should be_include([8,8,8])
+  end
+  
+  it "should allow centroids to be passed in to simplify processing" do
+    c1 = Centroid.new([4,4,4])
+    c2 = Centroid.new([5,5,5])
+    agent = Agent.process(:k => 2, :centroids => [c1, c2], *@node_list)
+    c1.position.should eql([2,2,2])
+    c2.position.should eql([8,8,8])
+  end
+    
+end

data/spec/kmeans/centroid_spec.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+describe Centroid do
+  
+  before do
+    @c = Centroid.new([1,2,3])
+  end
+  
+  it "should initialize with a position list" do
+    c = Centroid.new([1,2,3])
+    c.position.should eql([1,2,3])
+  end
+  
+  it "should have node storage" do
+    @c.nodes.should be_is_a(Array)
+  end
+  
+  it "should be able to add a node, to the centroid and the node (an optimization decision)" do
+    @n = new_node
+    @c.add_node(@n)
+    @n.centroid.should eql(@c)
+    @c.nodes.should be_include(@n)
+  end
+  
+  it "should be able to add many nodes at a time" do
+    @c.add_nodes(new_node, new_node, new_node)
+    @c.nodes.size.should eql(3)
+  end
+  
+  it "should be able to remove a node from the centroid and the node" do
+    @n = new_node
+    @c.add_node(@n)
+    @c.remove_node(@n)
+    @c.nodes.should_not be_include(@n)
+    @n.centroid.should be_nil
+  end
+  
+  it "should be able to remove a list of nodes" do
+    n1, n2, n3 = new_node, new_node, new_node
+    @c.add_node(n1, n2, n3)
+    @c.nodes.should eql([n1, n2, n3])
+    @c.remove_nodes(n2, n3)
+    @c.nodes.should eql([n1])
+  end
+  
+  it "should be able to rebalance the center of the centroid, based on the nodes" do
+    n1 = Node.new(1,2,3)
+    @c.add_node(n1)
+    @c.rebalance
+    @c.position.should eql([1,2,3])
+    n2 = Node.new(2,4,6)
+    @c.add_node(n2)
+    @c.rebalance
+    @c.position.should eql([3/2, 6/2, 9/2])
+  end
+end

data/spec/kmeans/node_spec.rb

@@ -0,0 +1,132 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+describe Node do
+  
+  before do
+    Node.clear_nodes!
+    @@boundaries = nil
+  end
+  
+  context "instance methods" do
+    before do
+      @node = Node.new(1,2,3)
+    end
+    
+    it "should record the position at initialization" do
+      @node.position.should eql([1,2,3])
+    end
+
+    it "should know about all new nodes on the class level" do
+      Node.nodes.should be_include(@node)
+    end
+
+    it "should have a centroid accessor" do
+      @node.centroid = :whatever
+      @node.centroid.should eql(:whatever)
+    end
+
+    # square root of 1^2 + 2^2 + 3^2 == square root of 14
+    it "should be able to calculate the euclidian distance between a node and its centroid" do
+      @c = Centroid.new([0,0,0])
+      @c.add_node(@node)
+      @node.distance.should eql(Math.sqrt(14))
+    end
+
+    it "should be able to scale the distance, so that some dimensions count more than others" do
+      @c = Centroid.new([0,0,0])
+      @node.distance(@c, [3,1,1]).should be_close(4.69, 0.001)
+    end
+
+    it "should be moveable from one centroid to another" do
+      c1 = Centroid.new([0,0,0])
+      c2 = Centroid.new([1,1,1])
+      c1.add_node(@node)
+      @node.move_to(c2)
+      c1.nodes.should_not be_include(@node)
+      c2.nodes.should be_include(@node)
+    end
+
+    it "should be able to clear all existing nodes for pseudo flexibility" do
+      n1 = Node.new(1,2,3)
+      Node.nodes.should be_include(n1)
+      Node.clear_nodes!
+      Node.nodes.should be_empty
+    end
+  
+  end
+  
+  it "should be able to supply the max and min boundaries for each dimension" do
+    n1 = Node.new 1
+    n2 = Node.new 5
+    Node.boundaries.should eql([[1,5]])
+  end
+  
+  it "should be able to find boundaries with the right cardinality" do
+    Node.new(1,2,3)
+    Node.boundaries.should_not be_nil
+    Node.send(:class_variable_get, :@@boundaries).should eql([[1,1], [2,2], [3,3]])
+  end
+  
+  it "should be able to generate a random centroid within the limits of all the nodes already created" do
+    n1 = Node.new 1
+    n2 = Node.new 5
+    100.times do
+      Node.random_centroid.should be_is_a(Centroid)
+      (Node.random_centroid.position.first >= 1).should be_true
+      (Node.random_centroid.position.first <= 5).should be_true
+    end
+  end
+  
+  it "should be able to add a node with just the dimensions" do
+    Node.clear_nodes!
+    Node.add_node([1,2,3])
+    Node.nodes.first.position.should eql([1,2,3])
+  end
+  
+  it "should keep the cardinality of the dimensions consitent" do
+    Node.new(1,2,3)
+    lambda{Node.new(1,2)}.should raise_error(ArgumentError, 'Node does not have the right number of positions')
+  end
+  
+  it "should reset the boundaries any time a new node is added" do
+    Node.new(1,2,3)
+    Node.find_boundaries
+    Node.send(:class_variable_get, :@@boundaries).should eql([[1,1], [2,2], [3,3]])
+    Node.new(2,2,2)
+    Node.send(:class_variable_get, :@@boundaries).should be_nil
+    Node.find_boundaries
+    Node.send(:class_variable_get, :@@boundaries).should eql([[1,2], [2,2], [2,3]])
+  end
+  
+  it "should be able to add many nodes at a time" do
+    Node.add_nodes [1,2,3], [4,5,3], [2,1,3]
+    Node.nodes.map{|n| n.position}.should eql([[1,2,3], [4,5,3], [2,1,3]])
+  end
+  
+  it "should know the dimension size" do
+    Node.add_node [1,2,3]
+    Node.dimension_size.should eql(3)
+    Node.clear_nodes!
+    Node.add_node [1,2]
+    Node.dimension_size.should eql(2)
+  end
+  
+  it "should be able to cluster the nodes" do
+    n1 = Node.new 1,1,1
+    n2 = Node.new 2,2,2
+    n3 = Node.new 3,3,3
+    n4 = Node.new 7,7,7
+    n5 = Node.new 8,8,8
+    n6 = Node.new 9,9,9
+    c1 = Centroid.new([2,2,2])
+    c2 = Centroid.new([8,8,8])
+    Node.cluster_to([c1, c2])
+    c1.nodes.should be_include(n1)
+    c1.nodes.should be_include(n2)
+    c1.nodes.should be_include(n3)
+    c2.nodes.should be_include(n4)
+    c2.nodes.should be_include(n5)
+    c2.nodes.should be_include(n6)
+  end
+  
+end

data/spec/kmeans_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Kmeans" do
+  it "should use TeguGears" do
+    defined?(TeguGears).should eql('constant')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$: << File.join(File.dirname(__FILE__), "/../lib") 
+require 'rubygems' 
+require 'spec' 
+require 'kmeans'
+require 'factory_girl'
+
+include KMeans
+
+Spec::Runner.configure do |config|
+  def new_node
+    @node = Node.new(1, 2, 3)
+  end
+end
+

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: davidrichards-kmeans
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- David Richards
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-22 00:00:00 -07:00
+default_executable: kmeans
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: davidrichards-tegu_gears
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A simple KMeans algorithm
+email: davidlamontrichards@gmail.com
+executables: 
+- kmeans
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION.yml
+- bin/kmeans
+- lib/ext
+- lib/ext/enumerable.rb
+- lib/ext/object.rb
+- lib/include_kmeans.rb
+- lib/kmeans
+- lib/kmeans/agent.rb
+- lib/kmeans/centroid.rb
+- lib/kmeans/node.rb
+- lib/kmeans.rb
+- spec/ext
+- spec/ext/enumerable_spec.rb
+- spec/ext/object_spec.rb
+- spec/kmeans
+- spec/kmeans/agent_spec.rb
+- spec/kmeans/centroid_spec.rb
+- spec/kmeans/node_spec.rb
+- spec/kmeans_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/davidrichards/kmeans
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+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: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: KMeans for clustering
+test_files: []
+