ai4ruby 1.11

data/test/clusterers/median_linkage_test.rb

@@ -0,0 +1,53 @@
+# Author::    Sergio Fierens (implementation)
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of 
+# the Mozilla Public License version 1.1  as published by the 
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/median_linkage'
+
+class Ai4r::Clusterers::MedianLinkage
+  attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix, :index_clusters
+end
+
+class Ai4r::Clusterers::MedianLinkageTest < Test::Unit::TestCase
+  
+  include Ai4r::Clusterers
+  include Ai4r::Data
+
+  @@data = [  [10, 3], [3, 10], [2, 8], [2, 5], [3, 8], [10, 3],
+              [1, 3], [8, 1], [2, 9], [2, 5], [3, 3], [9, 4]]
+            
+  @@expected_distance_matrix = [ 
+        [98.0], 
+        [89.0, 5.0], 
+        [68.0, 26.0, 9.0], 
+        [74.0, 4.0, 1.0, 10.0], 
+        [0.0, 98.0, 89.0, 68.0, 74.0], 
+        [81.0, 53.0, 26.0, 5.0, 29.0, 81.0], 
+        [8.0, 106.0, 85.0, 52.0, 74.0, 8.0, 53.0], 
+        [100.0, 2.0, 1.0, 16.0, 2.0, 100.0, 37.0, 100.0], 
+        [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0], 
+        [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
+        [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
+      
+   def setup
+     Ai4r::Clusterers::MedianLinkage.send(:public, 
+       *Ai4r::Clusterers::MedianLinkage.protected_instance_methods)  
+   end
+  
+   def test_linkage_distance
+    clusterer = Ai4r::Clusterers::MedianLinkage.new
+    clusterer.data_set = DataSet.new :data_items => @@data
+    clusterer.index_clusters = clusterer.create_initial_index_clusters
+    clusterer.distance_matrix = @@expected_distance_matrix
+    assert_equal 92.25, clusterer.linkage_distance(0,1,2)
+    assert_equal 15.25, clusterer.linkage_distance(4,2,5)
+  end
+
+end
+

data/test/clusterers/single_linkage_test.rb

@@ -0,0 +1,122 @@
+# Author::    Sergio Fierens (implementation)
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of 
+# the Mozilla Public License version 1.1  as published by the 
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/single_linkage'
+ 
+class Ai4r::Clusterers::SingleLinkage
+  attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix
+end
+ 
+class SingleLinkageTest < Test::Unit::TestCase
+  
+  include Ai4r::Clusterers
+  include Ai4r::Data
+ 
+  @@data = [ [10, 3], [3, 10], [2, 8], [2, 5], [3, 8], [10, 3],
+              [1, 3], [8, 1], [2, 9], [2, 5], [3, 3], [9, 4]]
+            
+  @@expected_distance_matrix = [
+        [98.0],
+        [89.0, 5.0],
+        [68.0, 26.0, 9.0],
+        [74.0, 4.0, 1.0, 10.0],
+        [0.0, 98.0, 89.0, 68.0, 74.0],
+        [81.0, 53.0, 26.0, 5.0, 29.0, 81.0],
+        [8.0, 106.0, 85.0, 52.0, 74.0, 8.0, 53.0],
+        [100.0, 2.0, 1.0, 16.0, 2.0, 100.0, 37.0, 100.0],
+        [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0],
+        [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0],
+        [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
+  
+  def setup
+    SingleLinkage.send(:public, *SingleLinkage.protected_instance_methods)
+  end
+  
+  def test_build
+    clusterer = Ai4r::Clusterers::SingleLinkage.new
+    clusterer.build(DataSet.new(:data_items => @@data), 4)
+    #draw_map(clusterer)
+    assert_equal 4, clusterer.clusters.length
+  end
+  
+  def test_eval
+    clusterer = Ai4r::Clusterers::SingleLinkage.new
+    clusterer.build(DataSet.new(:data_items => @@data), 4)
+    assert_equal 2, clusterer.eval([0,8])
+    assert_equal 0, clusterer.eval([8,0])
+  end
+ 
+  def test_create_distance_matrix
+    clusterer = Ai4r::Clusterers::SingleLinkage.new
+    clusterer.create_distance_matrix(DataSet.new(:data_items => @@data))
+    assert clusterer.distance_matrix
+    clusterer.distance_matrix.each_with_index do |row, row_index|
+      assert_equal row_index+1, row.length
+    end
+    assert_equal @@expected_distance_matrix, clusterer.distance_matrix
+  end
+  
+  def test_read_distance_matrix
+    clusterer = Ai4r::Clusterers::SingleLinkage.new
+    clusterer.distance_matrix = @@expected_distance_matrix
+    assert_equal 9.0, clusterer.read_distance_matrix(3, 2)
+    assert_equal 9.0, clusterer.read_distance_matrix(2, 3)
+    assert_equal 0, clusterer.read_distance_matrix(5, 5)
+  end
+  
+  def test_linkage_distance
+    clusterer = Ai4r::Clusterers::SingleLinkage.new
+    clusterer.distance_matrix = @@expected_distance_matrix
+    assert_equal 89, clusterer.linkage_distance(0,1,2)
+    assert_equal 1, clusterer.linkage_distance(4,2,5)
+  end
+  
+  def test_get_closest_clusters
+    clusterer = Ai4r::Clusterers::SingleLinkage.new
+    clusterer.distance_matrix = @@expected_distance_matrix
+    assert_equal [1,0], clusterer.get_closest_clusters([[0,1], [3,4]])
+    assert_equal [2,1], clusterer.get_closest_clusters([[3,4], [0,1], [5,6]])
+   end
+   
+  def test_create_initial_index_clusters
+    clusterer = Ai4r::Clusterers::SingleLinkage.new
+    clusterer.data_set = DataSet.new :data_items => @@data
+    index_clusters = clusterer.create_initial_index_clusters
+    assert_equal @@data.length, index_clusters.length
+    assert_equal 0, index_clusters.first.first
+    assert_equal @@data.length-1, index_clusters.last.first
+  end
+  
+  def test_merge_clusters
+    clusterer = Ai4r::Clusterers::SingleLinkage.new
+    clusters = clusterer.merge_clusters(1,2, [[1,2],[3,4],[5,6]])
+    assert_equal [[1,2], [3,4,5,6]], clusters.collect {|x| x.sort}
+    clusters = clusterer.merge_clusters(2,1, [[1,2],[3,4],[5,6]])
+    assert_equal [[1,2], [3,4,5,6]], clusters.collect {|x| x.sort}
+  end
+  
+  def test_distance_between_item_and_cluster
+    clusterer = Ai4r::Clusterers::SingleLinkage.new
+    assert_equal 8.0, clusterer.distance_between_item_and_cluster([1,2],
+      DataSet.new(:data_items => [[3,4],[5,6]]))
+  end
+  
+  private
+  def draw_map(clusterer)
+    map = Array.new(11) {Array.new(11, 0)}
+    clusterer.clusters.each_index do |i|
+      clusterer.clusters[i].data_items.each do |point|
+        map[point.first][point.last]=(i+1)
+      end
+    end
+    map.each { |row| puts row.inspect}
+  end
+  
+end

data/test/clusterers/ward_linkage_hierarchical_test.rb

@@ -0,0 +1,61 @@
+# Author::    Sergio Fierens (implementation)
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of 
+# the Mozilla Public License version 1.1  as published by the 
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/ward_linkage_hierarchical'
+
+class Ai4r::Clusterers::WardLinkageHierarchical
+  attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix, :index_clusters
+end
+
+class Ai4r::Clusterers::WardLinkageHierarchicalTest < Test::Unit::TestCase
+  
+  include Ai4r::Clusterers
+  include Ai4r::Data
+
+  @@data = [  [10, 3], [3, 10], [2, 8], [2, 5], [3, 8], [10, 3],
+              [1, 3], [8, 1], [2, 9], [2, 5], [3, 3], [9, 4]]
+            
+  @@expected_distance_matrix = [ 
+        [98.0], 
+        [89.0, 5.0], 
+        [68.0, 26.0, 9.0], 
+        [74.0, 4.0, 1.0, 10.0], 
+        [0.0, 98.0, 89.0, 68.0, 74.0], 
+        [81.0, 53.0, 26.0, 5.0, 29.0, 81.0], 
+        [8.0, 106.0, 85.0, 52.0, 74.0, 8.0, 53.0], 
+        [100.0, 2.0, 1.0, 16.0, 2.0, 100.0, 37.0, 100.0], 
+        [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0], 
+        [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
+        [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
+      
+   def setup
+     Ai4r::Clusterers::WardLinkageHierarchical.send(:public, 
+       *Ai4r::Clusterers::WardLinkageHierarchical.protected_instance_methods)  
+   end
+   
+  def test_linkage_distance
+    clusterer = Ai4r::Clusterers::WardLinkageHierarchical.new
+    clusterer.data_set = DataSet.new :data_items => @@data
+    clusterer.index_clusters = clusterer.create_initial_index_clusters
+    clusterer.distance_matrix = @@expected_distance_matrix
+    assert_in_delta 123.4166, clusterer.linkage_distance(0,1,2), 0.0001
+    assert_equal 27.75, clusterer.linkage_distance(4,2,5)
+  end
+
+  def test_cluster_tree
+    clusterer = Ai4r::Clusterers::WardLinkageHierarchical.new
+    clusterer.build(DataSet.new(:data_items => @@data), 1)
+
+    assert_equal clusterer.cluster_tree.length, @@data.length - 1
+  end
+    
+
+end
+

data/test/clusterers/ward_linkage_test.rb

@@ -0,0 +1,53 @@
+# Author::    Sergio Fierens (implementation)
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of 
+# the Mozilla Public License version 1.1  as published by the 
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/ward_linkage'
+
+class Ai4r::Clusterers::WardLinkage
+  attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix, :index_clusters
+end
+
+class Ai4r::Clusterers::WardLinkageTest < Test::Unit::TestCase
+  
+  include Ai4r::Clusterers
+  include Ai4r::Data
+
+  @@data = [  [10, 3], [3, 10], [2, 8], [2, 5], [3, 8], [10, 3],
+              [1, 3], [8, 1], [2, 9], [2, 5], [3, 3], [9, 4]]
+            
+  @@expected_distance_matrix = [ 
+        [98.0], 
+        [89.0, 5.0], 
+        [68.0, 26.0, 9.0], 
+        [74.0, 4.0, 1.0, 10.0], 
+        [0.0, 98.0, 89.0, 68.0, 74.0], 
+        [81.0, 53.0, 26.0, 5.0, 29.0, 81.0], 
+        [8.0, 106.0, 85.0, 52.0, 74.0, 8.0, 53.0], 
+        [100.0, 2.0, 1.0, 16.0, 2.0, 100.0, 37.0, 100.0], 
+        [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0], 
+        [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
+        [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
+      
+   def setup
+     Ai4r::Clusterers::WardLinkage.send(:public, 
+       *Ai4r::Clusterers::WardLinkage.protected_instance_methods)  
+   end
+   
+   def test_linkage_distance
+    clusterer = Ai4r::Clusterers::WardLinkage.new
+    clusterer.data_set = DataSet.new :data_items => @@data
+    clusterer.index_clusters = clusterer.create_initial_index_clusters
+    clusterer.distance_matrix = @@expected_distance_matrix
+    assert_in_delta 123.4166, clusterer.linkage_distance(0,1,2), 0.0001
+    assert_equal 27.75, clusterer.linkage_distance(4,2,5)
+  end
+
+end
+

data/test/clusterers/weighted_average_linkage_test.rb

@@ -0,0 +1,53 @@
+# Author::    Sergio Fierens (implementation)
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of 
+# the Mozilla Public License version 1.1  as published by the 
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/weighted_average_linkage'
+
+class Ai4r::Clusterers::WeightedAverageLinkage
+  attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix, :index_clusters
+end
+
+class Ai4r::Clusterers::WeightedAverageLinkageTest < Test::Unit::TestCase
+  
+  include Ai4r::Clusterers
+  include Ai4r::Data
+
+  @@data = [  [10, 3], [3, 10], [2, 8], [2, 5], [3, 8], [10, 3],
+              [1, 3], [8, 1], [2, 9], [2, 5], [3, 3], [9, 4]]
+            
+  @@expected_distance_matrix = [ 
+        [98.0], 
+        [89.0, 5.0], 
+        [68.0, 26.0, 9.0], 
+        [74.0, 4.0, 1.0, 10.0], 
+        [0.0, 98.0, 89.0, 68.0, 74.0], 
+        [81.0, 53.0, 26.0, 5.0, 29.0, 81.0], 
+        [8.0, 106.0, 85.0, 52.0, 74.0, 8.0, 53.0], 
+        [100.0, 2.0, 1.0, 16.0, 2.0, 100.0, 37.0, 100.0], 
+        [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0], 
+        [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
+        [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
+      
+   def setup
+     Ai4r::Clusterers::WeightedAverageLinkage.send(:public, 
+       *Ai4r::Clusterers::WeightedAverageLinkage.protected_instance_methods)  
+   end
+  
+   def test_linkage_distance
+    clusterer = Ai4r::Clusterers::WeightedAverageLinkage.new
+    clusterer.data_set = DataSet.new :data_items => @@data
+    clusterer.index_clusters = clusterer.create_initial_index_clusters
+    clusterer.distance_matrix = @@expected_distance_matrix
+    assert_equal 93.5, clusterer.linkage_distance(0,1,2)
+    assert_equal 37.5, clusterer.linkage_distance(4,2,5)
+  end
+
+end
+

data/test/data/data_set_test.rb

@@ -0,0 +1,96 @@
+# Author::    Sergio Fierens
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of 
+# the Mozilla Public License version 1.1  as published by the 
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/ai4r/data/data_set'
+
+module Ai4r
+  module Data
+    class DataSetTest < Test::Unit::TestCase
+      
+      def test_load_csv_with_labels
+        set = DataSet.new.load_csv_with_labels("#{File.dirname(__FILE__)}/data_set.csv")
+        assert_equal 120, set.data_items.length
+        assert_equal ["zone", "rooms", "size", "price"], set.data_labels
+      end
+      
+      def test_build_domains
+        domains =  [  Set.new(["New York", "Chicago"]), 
+                      Set.new(["M", "F"]), 
+                      [5, 85],
+                      Set.new(["Y", "N"]) ]
+        data = [  [ "New York", "M", 23, "Y"],
+                  [ "Chicago", "M", 85, "Y"],
+                  [ "New York", "F", 32, "Y"],
+                  [ "New York", "M", 5, "N"],
+                  [ "Chicago", "M", 15, "N"],
+                  [ "Chicago", "F", 45, "Y"] ]
+        labels = ["city", "gender", "age", "result"]
+        set = DataSet.new({:data_items => data, :data_labels => labels})
+        assert_equal domains, set.build_domains
+        assert_equal domains[0], set.build_domain("city")
+        assert_equal domains[1], set.build_domain(1)
+        assert_equal domains[2], set.build_domain("age")
+        assert_equal domains[3], set.build_domain("result")
+      end
+      
+      def test_set_data_labels
+        labels = ["A", "B"]
+        set = DataSet.new.set_data_labels(labels)
+        assert_equal labels, set.data_labels
+        set = DataSet.new(:data_labels => labels)
+        assert_equal labels, set.data_labels
+        set = DataSet.new(:data_items => [[ 1, 2, 3]])
+        assert_raise(ArgumentError) { set.set_data_labels(labels) }
+      end
+
+      def test_set_data_items
+        items = [  [ "New York", "M", "Y"],
+                  [ "Chicago", "M", "Y"],
+                  [ "New York", "F", "Y"],
+                  [ "New York", "M", "N"],
+                  [ "Chicago", "M", "N"],
+                  [ "Chicago", "F", "Y"] ]
+        set = DataSet.new.set_data_items(items)
+        assert_equal items, set.data_items
+        assert_equal 3, set.data_labels.length
+        items << items.first[0..-2]
+        assert_raise(ArgumentError) { set.set_data_items(items) }
+        assert_raise(ArgumentError) { set.set_data_items(nil) }
+        assert_raise(ArgumentError) { set.set_data_items([1]) }
+      end
+     
+      def test_get_mean_or_mode
+                items = [  [ "New York", 25, "Y"],
+                  [ "New York", 55, "Y"],
+                  [ "Chicago", 23, "Y"],
+                  [ "Boston", 23, "N"],
+                  [ "Chicago", 12, "N"],
+                  [ "Chicago", 87, "Y"] ]
+        set = DataSet.new.set_data_items(items)
+        assert_equal ["Chicago", 37.5, "Y"], set.get_mean_or_mode
+      end
+      
+      def test_index
+        items = [  [ "New York", 25, "Y"],
+                  [ "New York", 55, "Y"],
+                  [ "Chicago", 23, "Y"],
+                  [ "Boston", 23, "N"],
+                  [ "Chicago", 12, "N"],
+                  [ "Chicago", 87, "Y"] ]
+        set = DataSet.new.set_data_items(items)
+        assert_equal set.data_labels, set[0].data_labels
+        assert_equal [[ "New York", 25, "Y"]], set[0].data_items
+        assert_equal [[ "Chicago", 23, "Y"],[ "Boston", 23, "N"]], set[2..3].data_items
+        assert_equal items[1..-1], set[1..-1].data_items
+      end
+     
+    end
+  end
+end

data/test/data/proximity_test.rb

@@ -0,0 +1,81 @@
+# Author::    Sergio Fierens
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of 
+# the Mozilla Public License version 1.1  as published by the 
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/ai4r/data/proximity'
+
+module Ai4r
+  module Data
+    class ProximityTest < Test::Unit::TestCase
+          
+      @@delta = 0.0001    
+      @@data1 = [rand*10, rand*10, rand*-10]
+      @@data2 = [rand*10, rand*-10, rand*10]
+      
+      def test_squared_euclidean_distance
+          assert_equal 0, Proximity.squared_euclidean_distance(@@data1, @@data1)
+          assert_equal  Proximity.squared_euclidean_distance(@@data1, @@data2), 
+                        Proximity.squared_euclidean_distance(@@data2, @@data1)
+          assert 0 <= Proximity.squared_euclidean_distance(@@data1, @@data1)
+          assert_equal 2, Proximity.squared_euclidean_distance([1,1], [2,2])
+          assert_equal 9, Proximity.squared_euclidean_distance([3], [0])
+      end
+      
+      def test_euclidean_distance
+          assert_equal 0, Proximity.euclidean_distance(@@data1, @@data1)
+          assert_equal  Proximity.euclidean_distance(@@data1, @@data2), 
+                        Proximity.euclidean_distance(@@data2, @@data1)
+          assert 0 <= Proximity.euclidean_distance(@@data1, @@data1)                        
+          assert_equal Math.sqrt(2), Proximity.euclidean_distance([1,1], [2,2])
+          assert_equal 3, Proximity.euclidean_distance([3], [0])
+      end
+
+      def test_manhattan_distance
+          assert_equal 0, Proximity.manhattan_distance(@@data1, @@data1)
+          assert_equal  Proximity.manhattan_distance(@@data1, @@data2), 
+                        Proximity.manhattan_distance(@@data2, @@data1)
+          assert 0 <= Proximity.manhattan_distance(@@data1, @@data1)                        
+          assert_equal 2, Proximity.manhattan_distance([1,1], [2,2])
+          assert_equal 9, Proximity.manhattan_distance([1,10], [2,2])
+          assert_equal 3, Proximity.manhattan_distance([3], [0])
+      end      
+      
+      def test_sup_distance
+          assert_equal 0, Proximity.sup_distance(@@data1, @@data1)
+          assert_equal  Proximity.sup_distance(@@data1, @@data2), 
+                        Proximity.sup_distance(@@data2, @@data1)
+          assert 0 <= Proximity.sup_distance(@@data1, @@data1)                        
+          assert_equal 1, Proximity.sup_distance([1,1], [2,2])
+          assert_equal 8, Proximity.sup_distance([1,10], [2,2])
+          assert_equal 3, Proximity.sup_distance([3], [0])
+      end  
+      
+      def test_hamming_distance
+          assert_equal 0, Proximity.hamming_distance(@@data1, @@data1)
+          assert_equal  Proximity.hamming_distance(@@data1, @@data2), 
+                        Proximity.hamming_distance(@@data2, @@data1)
+          assert 0 <= Proximity.hamming_distance(@@data1, @@data1)                        
+          assert_equal 1, Proximity.hamming_distance([1,1], [0,1])
+          assert_equal 2, Proximity.hamming_distance([1,10], [2,2])
+          assert_equal 1, Proximity.hamming_distance([3], [0])
+      end 
+      
+      def test_simple_matching_distance
+          assert_equal 0, Proximity.simple_matching_distance(@@data1, @@data1)
+          assert_equal  Proximity.simple_matching_distance(@@data1, @@data2), 
+                        Proximity.simple_matching_distance(@@data2, @@data1)
+          assert 0 <= Proximity.simple_matching_distance(@@data1, @@data1)                        
+          assert_equal 1, Proximity.simple_matching_distance([1,2], [0,1])
+          assert_equal 1.0/0, Proximity.simple_matching_distance([1,10], [2,2])
+          assert_equal 1.0/0, Proximity.simple_matching_distance([3], [0])
+      end       
+      
+    end
+  end
+end