rbcluster 0.0.1

data/lib/rbcluster.rb

@@ -0,0 +1,5 @@
+require 'rbcluster/version'
+require 'rbcluster/rbcluster'
+require 'rbcluster/tree'
+
+RbCluster = Cluster

data/lib/rbcluster/tree.rb

@@ -0,0 +1,20 @@
+module Cluster
+  class Tree
+    def initialize(nodes)
+      raise NotImplementedError, "patches welcome :)"
+
+      nodes.each_with_index do |node, idx|
+        unless node.kind_of?(Node)
+          raise ArgumentError, "expected #{Node.class}, got #{node.class} at index #{idx}"
+        end
+      end
+
+      @nodes = nodes
+    end
+
+    def size
+      @nodes.size
+    end
+
+  end
+end

data/lib/rbcluster/version.rb

@@ -0,0 +1,3 @@
+module Cluster
+  VERSION = "0.0.1"
+end

data/rbcluster.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rbcluster/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rbcluster"
+  s.version     = Cluster::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jari Bakken", "Michiel Jan Laurens de Hoon"]
+  s.email       = ["jari.bakken@gmail.com"]
+  s.homepage    = "http://bonsai.hgc.jp/~mdehoon/software/cluster/software.htm"
+  s.summary     = %q{Ruby bindings for the Cluster C library}
+  s.description = %q{This gem provides a Ruby extension to the clustering routines in the C Clustering Library (which also backs e.g. Python's pycluster and Perl's Algorithm::Cluster).}
+
+  s.rubyforge_project = "rbcluster"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.extensions    = `git ls-files -- ext/**/extconf.rb`.split("\n")
+
+  s.add_development_dependency "rake-compiler"
+  s.add_development_dependency "rspec", "~> 2.6.0"
+end

data/spec/clustercentroids_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe "Cluster.clustercentroids" do
+  pending
+end
+

data/spec/clusterdistance_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe "Cluster.clusterdistance" do
+  it "calculates distances for data set 1" do
+    weight = [ 1,1,1,1,1 ]
+    data   = [[  1.1, 2.2, 3.3, 4.4, 5.5, ], 
+              [  3.1, 3.2, 1.3, 2.4, 1.5, ], 
+              [  4.1, 2.2, 0.3, 5.4, 0.5, ], 
+              [ 12.1, 2.0, 0.0, 5.0, 0.0, ]]
+              
+    mask   = [[ 1, 1, 1, 1, 1], 
+              [ 1, 1, 1, 1, 1], 
+              [ 1, 1, 1, 1, 1], 
+              [ 1, 1, 1, 1, 1]]
+
+    # Cluster assignments
+    c1 = [0]
+    c2 = [1,2]
+    c3 = [3]
+
+    distance = Cluster.clusterdistance data, c1, c2, :mask      => mask, 
+                                                     :weight    => weight,
+                                                     :dist      => 'e',
+                                                     :method    => 'a',
+                                                     :transpose => false
+                                             
+    distance.should be_within(0.001).of(6.650)
+
+    distance = Cluster.clusterdistance data, c1, c3, :mask      => mask, 
+                                                     :weight    => weight,
+                                                     :dist      => 'e',
+                                                     :method    => 'a',
+                                                     :transpose => false
+
+    distance.should be_within(0.001).of(32.508)                                             
+
+    distance = Cluster.clusterdistance data, c2, c3, :mask      => mask, 
+                                                     :weight    => weight,
+                                                     :dist      => 'e',
+                                                     :method    => 'a',
+                                                     :transpose => false
+                                             
+    distance.should be_within(0.001).of(15.118)                                             
+  end
+  
+  it "calculates distances for data set 2" do
+    weight =  [ 1,1 ]
+    data   =  [[ 1.1, 1.2 ],
+               [ 1.4, 1.3 ],
+               [ 1.1, 1.5 ],
+               [ 2.0, 1.5 ],
+               [ 1.7, 1.9 ],
+               [ 1.7, 1.9 ],
+               [ 5.7, 5.9 ],
+               [ 5.7, 5.9 ],
+               [ 3.1, 3.3 ],
+               [ 5.4, 5.3 ],
+               [ 5.1, 5.5 ],
+               [ 5.0, 5.5 ],
+               [ 5.1, 5.2 ]]
+    mask = [[ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ],
+            [ 1, 1 ]]
+
+    # Cluster assignments
+    c1 = [ 0, 1, 2, 3 ]
+    c2 = [ 4, 5, 6, 7 ]
+    c3 = [ 8 ]
+
+    distance = Cluster.clusterdistance data, c1, c2, :mask      => mask, 
+                                                     :weight    => weight,
+                                                     :dist      => 'e',
+                                                     :method    => 'a',
+                                                     :transpose => false
+
+    distance.should be_within(0.001).of(5.833)                                                 
+    
+    distance = Cluster.clusterdistance data, c1, c3, :mask      => mask, 
+                                                     :weight    => weight,
+                                                     :dist      => 'e',
+                                                     :method    => 'a',
+                                                     :transpose => false
+
+    distance.should be_within(0.001).of(3.298)                                                 
+    
+    
+    distance = Cluster.clusterdistance data, c2, c3, :mask      => mask, 
+                                                     :weight    => weight,
+                                                     :dist      => 'e',
+                                                     :method    => 'a',
+                                                     :transpose => false
+
+    distance.should be_within(0.001).of(0.360)                                                 
+  end
+end
+

data/spec/clustermedoids_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe "Cluster.clustermedoids" do
+  pending
+end
+

data/spec/cuttree_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe "Cluster.cuttree" do
+  pending
+end
+

data/spec/kcluster_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe "Cluster.kcluster" do
+  it "should run kcluster for the given data" do
+    nclusters = 3
+    # First data set
+    weight = [1,1,1,1,1]
+    data   = [[ 1.1, 2.2, 3.3, 4.4, 5.5],
+              [ 3.1, 3.2, 1.3, 2.4, 1.5],
+              [ 4.1, 2.2, 0.3, 5.4, 0.5],
+              [12.1, 2.0, 0.0, 5.0, 0.0]]
+    mask   = [[ 1, 1, 1, 1, 1],
+             [ 1, 1, 1, 1, 1],
+             [ 1, 1, 1, 1, 1],
+             [ 1, 1, 1, 1, 1]]
+
+
+    clusterids, error, nfound = Cluster.kcluster data, :clusters  => nclusters,
+                                                       :mask      => mask,
+                                                       :weight    => weight,
+                                                       :transpose => false,
+                                                       :passes    => 100,
+                                                       :method    => 'a',
+                                                       :dist      => 'e'
+
+    clusterids.size.should == data.size
+    correct = [0,1,1,2]
+    mapping = nclusters.times.map { |n| clusterids[correct.index(n)] }
+    clusterids.each_with_index do |ci, i|
+      ci.should == mapping[correct[i]]
+    end
+  end
+
+  it "should run kcluster for a second set of data" do
+    nclusters = 3
+    weight = [1,1]
+    data = [ [ 1.1, 1.2 ],
+             [ 1.4, 1.3 ],
+             [ 1.1, 1.5 ],
+             [ 2.0, 1.5 ],
+             [ 1.7, 1.9 ],
+             [ 1.7, 1.9 ],
+             [ 5.7, 5.9 ],
+             [ 5.7, 5.9 ],
+             [ 3.1, 3.3 ],
+             [ 5.4, 5.3 ],
+             [ 5.1, 5.5 ],
+             [ 5.0, 5.5 ],
+             [ 5.1, 5.2 ]]
+
+    mask = [ [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ],
+             [ 1, 1 ]]
+
+    clusterids, error, nfound = Cluster.kcluster data, :clusters  => nclusters,
+                                                       :mask      => mask,
+                                                       :weight    => weight,
+                                                       :transpose => false,
+                                                       :passes    => 100,
+                                                       :method    => 'a',
+                                                       :dist      => 'e'
+
+    clusterids.size.should == data.size
+
+    correct = [0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 1]
+    mapping = nclusters.times.map { |n| clusterids[correct.index(n)] }
+    clusterids.each_with_index do |ci, i|
+      ci.should == mapping[correct[i]]
+    end
+  end
+
+  it "raises ArgumentError if passed inconsistent data" do
+    lambda {
+      Cluster.kcluster [[1,2,3], [1,2,3,4]], {}
+    }.should raise_error(ArgumentError, "expected 3 columns, row has 4")
+  end
+
+  it "will use default options" do
+    data = [[1,1,1], [10,10,0], [0,0,0]]
+    clusterids, error, nfound = Cluster.kcluster(data, :passes => 1000)
+
+    clusterids.should be_kind_of(Array)
+    [[0, 1, 0], [1, 0, 1]].should include(clusterids)
+  end
+end

data/spec/kmedoids_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe "Cluster.kmedoids" do
+  it "should calculate kmedoids from a distance matrix" do
+    data = [[2.2, 3.3, 4.4],
+           [2.1, 1.4, 5.6],
+           [7.8, 9.0, 1.2],
+           [4.5, 2.3, 1.5],
+           [4.2, 2.4, 1.9],
+           [3.6, 3.1, 9.3],
+           [2.3, 1.2, 3.9],
+           [4.2, 9.6, 9.3],
+           [1.7, 8.9, 1.1]]
+           
+    mask = [[1, 1, 1],
+           [1, 1, 1],
+           [0, 1, 1],
+           [1, 1, 1],
+           [1, 1, 1],
+           [0, 1, 0],
+           [1, 1, 1],
+           [1, 0, 1],
+           [1, 1, 1]]
+           
+    weight = [2.0, 1.0, 0.5]
+    matrix = Cluster.distancematrix data, :mask => mask, :weight => weight
+
+    matrix[1][0].should be_within(0.001).of(1.243)
+
+    matrix[2][0].should be_within(0.001).of(25.073)
+    matrix[2][1].should be_within(0.001).of(44.960)
+
+    matrix[3][0].should be_within(0.001).of(4.510)
+    matrix[3][1].should be_within(0.001).of(5.924)
+    matrix[3][2].should be_within(0.001).of(29.957)
+
+    matrix[4][0].should be_within(0.001).of(3.410)
+    matrix[4][1].should be_within(0.001).of(4.761)
+    matrix[4][2].should be_within(0.001).of(29.203)
+    matrix[4][3].should be_within(0.001).of(0.077)
+
+    matrix[5][0].should be_within(0.001).of(0.040)
+    matrix[5][1].should be_within(0.001).of(2.890)
+    matrix[5][2].should be_within(0.001).of(34.810)
+    matrix[5][3].should be_within(0.001).of(0.640)
+    matrix[5][4].should be_within(0.001).of(0.490)
+
+    matrix[6][0].should be_within(0.001).of(1.301)
+    matrix[6][1].should be_within(0.001).of(0.447)
+    matrix[6][2].should be_within(0.001).of(42.990)
+    matrix[6][3].should be_within(0.001).of(3.934)
+    matrix[6][4].should be_within(0.001).of(3.046)
+    matrix[6][5].should be_within(0.001).of(3.610)
+
+    matrix[7][0].should be_within(0.001).of(8.002)
+    matrix[7][1].should be_within(0.001).of(6.266)
+    matrix[7][2].should be_within(0.001).of(65.610)
+    matrix[7][3].should be_within(0.001).of(12.240)
+    matrix[7][4].should be_within(0.001).of(10.952)
+    matrix[7][5].should be_within(0.001).of(0.000)
+    matrix[7][6].should be_within(0.001).of(8.720)
+
+    matrix[8][0].should be_within(0.001).of(10.659)
+    matrix[8][1].should be_within(0.001).of(19.056)
+    matrix[8][2].should be_within(0.001).of(0.010)
+    matrix[8][3].should be_within(0.001).of(16.949)
+    matrix[8][4].should be_within(0.001).of(15.734)
+    matrix[8][5].should be_within(0.001).of(33.640)
+    matrix[8][6].should be_within(0.001).of(18.266)
+    matrix[8][7].should be_within(0.001).of(18.448)
+    
+    clusterid, error, nfound = Cluster.kmedoids matrix, :passes => 1000
+    
+    clusterid[0].should == 5
+    clusterid[1].should == 5
+    clusterid[2].should == 2
+    clusterid[3].should == 5
+    clusterid[4].should == 5
+    clusterid[5].should == 5
+    clusterid[6].should == 5
+    clusterid[7].should == 5
+    clusterid[8].should == 2
+    
+    error.should be_within(0.001).of(7.680)
+  end
+end

data/spec/median_mean_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe "Cluster.{median,mean}" do
+  let(:data) {
+    [
+      [ 34.3, 3, 2 ],
+      [ 5, 10, 15, 20],
+      [ 1, 2, 3, 5, 7, 11, 13, 17],
+      [ 100, 19, 3, 1.5, 1.4, 1, 1, 1],
+    ]
+  }
+  
+  it "calculates the median" do
+    Cluster.median(data[0]).should == 3.0
+    Cluster.median(data[1]).should == 12.5
+    Cluster.median(data[2]).should == 6.0
+    Cluster.median(data[3]).should == 1.45
+  end
+  
+  it "calculates the mean" do
+    Cluster.mean(data[0]).should be_within(0.001).of(13.1)
+    Cluster.mean(data[1]).should be_within(0.001).of(12.5)
+    Cluster.mean(data[2]).should be_within(0.001).of(7.375)
+    Cluster.mean(data[3]).should be_within(0.001).of(15.988)
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Cluster
+  describe Node do
+    it "creates a new node with left/right" do
+      n = Node.new(2, 3)
+      n.left.should == 2
+      n.right.should == 3
+    end
+
+    it "takes an optional distance" do
+      n = Node.new(2, 3, 0.91)
+
+      n.left.should == 2
+      n.right.should == 3
+      n.distance.should == 0.91
+    end
+
+    it "is mutable" do
+      n = Node.new(2, 3, 0.91)
+
+      n.left = 4
+      n.right = 5
+      n.distance = 2.1
+    end
+  end
+end

data/spec/pca_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe "Cluster.pca" do
+  it "performs principal component analysis where nrows > ncols" do
+    data = [
+      [ 3.1, 1.2 ],
+      [ 1.4, 1.3 ],
+      [ 1.1, 1.5 ],
+      [ 2.0, 1.5 ],
+      [ 1.7, 1.9 ],
+      [ 1.7, 1.9 ],
+      [ 5.7, 5.9 ],
+      [ 5.7, 5.9 ],
+      [ 3.1, 3.3 ],
+      [ 5.4, 5.3 ],
+      [ 5.1, 5.5 ],
+      [ 5.0, 5.5 ],
+      [ 5.1, 5.2 ],
+    ]
+
+    mean, coordinates, pc, eigenvalues = Cluster.pca(data)
+
+    mean[0].should be_within(0.001).of(3.5461538461538464)
+    mean[1].should be_within(0.001).of(3.5307692307692311)
+    coordinates[0][0].should be_within(0.001).of(2.0323189722653883)
+    coordinates[0][1].should be_within(0.001).of(1.2252420399694917)
+    coordinates[1][0].should be_within(0.001).of(3.0936985166252251)
+    coordinates[1][1].should be_within(0.001).of(-0.10647619705157851)
+    coordinates[2][0].should be_within(0.001).of(3.1453186907749426)
+    coordinates[2][1].should be_within(0.001).of(-0.46331699855941139)
+    coordinates[3][0].should be_within(0.001).of(2.5440202962223761)
+    coordinates[3][1].should be_within(0.001).of(0.20633980959571077)
+    coordinates[4][0].should be_within(0.001).of(2.4468278463376221)
+    coordinates[4][1].should be_within(0.001).of(-0.28412285736824866)
+    coordinates[5][0].should be_within(0.001).of(2.4468278463376221)
+    coordinates[5][1].should be_within(0.001).of(-0.28412285736824866)
+    coordinates[6][0].should be_within(0.001).of(-3.2018619434743254)
+    coordinates[6][1].should be_within(0.001).of(0.019692314198662915)
+    coordinates[7][0].should be_within(0.001).of(-3.2018619434743254)
+    coordinates[7][1].should be_within(0.001).of(0.019692314198662915)
+    coordinates[8][0].should be_within(0.001).of(0.46978641990344067)
+    coordinates[8][1].should be_within(0.001).of(-0.17778754731982949)
+    coordinates[9][0].should be_within(0.001).of(-2.5549912731867215)
+    coordinates[9][1].should be_within(0.001).of(0.19733897451533403)
+    coordinates[10][0].should be_within(0.001).of(-2.5033710990370044)
+    coordinates[10][1].should be_within(0.001).of(-0.15950182699250004)
+    coordinates[11][0].should be_within(0.001).of(-2.4365601663089413)
+    coordinates[11][1].should be_within(0.001).of(-0.23390813900973562)
+    coordinates[12][0].should be_within(0.001).of(-2.2801521629852974)
+    coordinates[12][1].should be_within(0.001).of(  0.0409309711916888)
+    pc[0][0].should be_within(0.001).of(-0.66810932728062988)
+    pc[0][1].should be_within(0.001).of(-0.74406312017235743)
+    pc[1][0].should be_within(0.001).of(  0.74406312017235743)
+    pc[1][1].should be_within(0.001).of(-0.66810932728062988)
+    eigenvalues[0].should be_within(0.001).of( 9.3110471246032844)
+    eigenvalues[1].should be_within(0.001).of( 1.4437456297481428)
+  end
+
+  it "performs principal component analysis where ncols > nrows" do
+    data = [[ 2.3, 4.5, 1.2, 6.7, 5.3, 7.1],
+            [ 1.3, 6.5, 2.2, 5.7, 6.2, 9.1],
+            [ 3.2, 7.2, 3.2, 7.4, 7.3, 8.9],
+            [ 4.2, 5.2, 9.2, 4.4, 6.3, 7.2]]
+
+    mean, coordinates, pc, eigenvalues = Cluster.pca(data)
+
+    mean[0].should be_within(0.001).of( 2.7500)
+    mean[1].should be_within(0.001).of( 5.8500)
+    mean[2].should be_within(0.001).of( 3.9500)
+    mean[3].should be_within(0.001).of( 6.0500)
+    mean[4].should be_within(0.001).of( 6.2750)
+    mean[5].should be_within(0.001).of( 8.0750)
+    coordinates[0][0].should be_within(0.001).of(2.6460846688406905)
+    coordinates[0][1].should be_within(0.001).of(-2.1421701432732418)
+    coordinates[0][2].should be_within(0.001).of(-0.56620932754145858)
+    coordinates[0][3].should be_within(0.001).of(0.0)
+    coordinates[1][0].should be_within(0.001).of(2.0644120899917544)
+    coordinates[1][1].should be_within(0.001).of(0.55542108669180323)
+    coordinates[1][2].should be_within(0.001).of(1.4818772348457117)
+    coordinates[1][3].should be_within(0.001).of(0.0)
+    coordinates[2][0].should be_within(0.001).of(1.0686641862092987)
+    coordinates[2][1].should be_within(0.001).of(1.9994412069101073)
+    coordinates[2][2].should be_within(0.001).of(-1.000720598980291)
+    coordinates[2][3].should be_within(0.001).of(0.0)
+    coordinates[3][0].should be_within(0.001).of(-5.77916094504174)
+    coordinates[3][1].should be_within(0.001).of(-0.41269215032867046)
+    coordinates[3][2].should be_within(0.001).of(0.085052691676038017)
+    coordinates[3][3].should be_within(0.001).of(0.0)
+    pc[0][0].should be_within(0.001).of(-0.26379660005997291)
+    pc[0][1].should be_within(0.001).of(  0.064814972617134495)
+    pc[0][2].should be_within(0.001).of(-0.91763310094893846)
+    pc[0][3].should be_within(0.001).of(  0.26145408875373249)
+    pc[1][0].should be_within(0.001).of(  0.05073770520434398)
+    pc[1][1].should be_within(0.001).of(  0.68616983388698793)
+    pc[1][2].should be_within(0.001).of(  0.13819106187213354)
+    pc[1][3].should be_within(0.001).of(  0.19782544121828985)
+    pc[2][0].should be_within(0.001).of(-0.63000893660095947)
+    pc[2][1].should be_within(0.001).of(  0.091155993862151397)
+    pc[2][2].should be_within(0.001).of(  0.045630391256086845)
+    pc[2][3].should be_within(0.001).of(-0.67456694780914772)
+
+    # As the last eigenvalue is zero, the corresponding eigenvector is
+    # strongly affected by roundoff error, and is not being tested here.
+    # For PCA, this doesn't matter since all data have a zero coefficient
+    # along this eigenvector.
+
+    eigenvalues[0].should be_within(0.001).of( 6.7678878332578778)
+    eigenvalues[1].should be_within(0.001).of( 3.0108911400291856)
+    eigenvalues[2].should be_within(0.001).of( 1.8775592718563467)
+    eigenvalues[3].should be_within(0.001).of( 0.0)
+  end
+end
+