morphological_metrics 1.2.0 → 1.3.0

data/test/mm/test_metric.rb

@@ -1,168 +1,160 @@
-require 'minitest/autorun'
-
-require 'mm/metric'
-
-class TestMM < Minitest::Test; end
-
-class TestMM::TestMetric < Minitest::Test
-  def setup
-    @ordered ||= true
-    @pair ||= :linear
-    @scale ||= :none
-    @intra_delta ||= :abs
-    @inter_delta ||= :abs
-    @metric = MM::Metric.new(ordered: @ordered, pair: @pair, scale: @scale, intra_delta: @intra_delta, inter_delta: @inter_delta)
-
-    # Setting up the sample vectors for many of the examples
-    @v1 = [1, 6, 2, 5, 11]
-    @v2 = [3, 15, 13, 2, 9]
-  end
-
-  def test_creates_new_metric
-    assert @metric.is_a? MM::Metric
-  end
-
-  def test_metric_responds_to_call 
-    assert_respond_to @metric, :call 
-  end
-
-  class TestGetPairs < self
-    class TestLinearPairs < self
-      def test_gets_linear_pairs
-        exp = [
-          [[1, 6], [6, 2], [2, 5], [5, 11]],
-          [[3, 15], [15, 13], [13, 2], [2, 9]]
-        ]
-        assert_equal exp, @metric.send(:get_pairs, @v1, @v2)
-      end
-    end
-
-    class TestCombinatorialPairs < self
-      def setup
-        @pair = :combinatorial
-        super
-      end
-      def test_gets_combinatorial_pairs
-        exp = [
-          [[1, 6], [1, 2], [1, 5], [1, 11], [6, 2], [6, 5],
-            [6, 11], [2, 5], [2, 11], [5, 11]],
-          [[3, 15], [3, 13], [3, 2], [3, 9], [15, 13], [15, 2],
-            [15, 9], [13, 2], [13, 9], [2, 9]]
-        ]
-        assert_equal exp, @metric.send(:get_pairs, @v1, @v2)
-      end
-    end
-  end
-
-  class TestDeltas < self
-    class TestIntraDelta < self
-      def test_gets_intra_delta
-        pairs = [
-          [[1, 6], [6, 2], [2, 5], [5, 11]],
-          [[3, 15], [15, 13], [13, 2], [2, 9]]
-        ]
-        exp = [
-          [5, 4, 3, 6],
-          [12, 2, 11, 7]
-        ]
-        assert_equal exp, @metric.send(:intra_delta, pairs)
-      end
-      def test_intra_delta_proc
-        @metric.intra_delta = ->(*vp) {nil}
-        assert_instance_of Proc, @metric.instance_variable_get(:@intra_delta)
-      end
-    end
-
-    class TestInterDelta < self
-      def setup
-        super
-        @diffs = [
-          [5, 4, 3, 6],
-          [12, 2, 11, 7]
-        ]
-      end
-      def test_gets_inter_delta_ordered
-        exp = 4.5
-        assert_equal exp, @metric.send(:inter_delta, @diffs) 
-      end
-      def test_inter_delta_proc
-        @metric.inter_delta = ->(*diffs) {nil}
-        assert_instance_of Proc, @metric.instance_variable_get(:@inter_delta)
-      end
-    end
-  end
-
-  class TestScaling < self
-    def setup
-      super
-      @unscaled = [
-        [5, 4, 3, 6],
-        [12, 2, 11, 7]
-      ]
-    end
-
-    def test_assigns_scaling_proc
-      @metric.scale = ->(pairs) {}
-      scale = @metric.instance_variable_get :@scale
-      assert_equal Proc, scale.class 
-    end
-
-    def test_no_scaling
-      assert_equal @unscaled, @metric.send(:scale, @unscaled)
-    end
-
-    # TODO: This is a complicated test and I don't like it
-    def test_absolute_scaling
-      @metric.scale = :absolute
-      @exp = [
-        [0.417, 0.333, 0.25, 0.5],
-        [1.0, 0.167, 0.917, 0.583]
-      ]
-      actual = @metric.send :scale, @unscaled
-      actual.each_with_index do |v, i|
-        v.each_with_index do |w, j|
-          assert_in_delta @exp[i][j], w, 0.001 
-        end
-      end
-    end
-
-    def test_relative_scaling
-      @metric.scale = :relative
-      @exp = [
-        [0.833, 0.667, 0.5, 1.0],
-        [1.0, 0.167, 0.917, 0.583]
-      ]
-      actual = @metric.send :scale, @unscaled
-      actual.each_with_index do |v, i|
-        v.each_with_index do |w, j|
-          assert_in_delta @exp[i][j], w, 0.001 
-        end
-      end
-    end
-  end
-
-  class TestMagnitudeMetric < self
-    # Definitions of expected results
-    @exp = {
-      :olm => {:scale_none => 4.5, :scale_absolute => 0.375},
-      :ocm => {:scale_none => 5.2, :scale_absolute => 0.4},
-      :ulm => {:scale_none => 3.5, :scale_absolute => 0.29167},
-      :ucm => {:scale_none => 2.4, :scale_absolute => 0.1846},
-      :old => {:scale_none => 0.25},
-      :ocd => {:scale_none => 0.4},
-      :uld => {:scale_none => 0.25},
-      :ucd => {:scale_none => 0.4}
-    }
-
-    @exp.each do |metric, expected|
-      expected.each do |scaling, e|
-        define_method "test_#{metric}_#{scaling}" do
-          m = ::MM::Metric.send(metric)
-          m.scale = /_(.*)$/.match(scaling)[1].to_sym
-          assert_in_delta e, m.call(@v1, @v2), 0.001
-        end
-      end
-    end
-  end
-end
-
+require 'minitest/autorun'
+
+require 'mm/metric'
+
+class TestMM < Minitest::Test; end
+
+class TestMM::TestMetric < Minitest::Test
+  def setup
+    @ordered ||= true
+    @pair ||= :linear
+    @scale ||= :none
+    @intra_delta ||= :abs
+    @inter_delta ||= :abs
+    @metric = MM::Metric.new(ordered: @ordered, pair: @pair, scale: @scale, intra_delta: @intra_delta, inter_delta: @inter_delta)
+
+    # Setting up the sample vectors for many of the examples
+    @v1 = [1, 6, 2, 5, 11]
+    @v2 = [3, 15, 13, 2, 9]
+  end
+
+  def test_creates_new_metric
+    assert @metric.is_a? MM::Metric
+  end
+
+  def test_metric_responds_to_call 
+    assert_respond_to @metric, :call 
+  end
+
+  class TestGetPairs < self
+    class TestLinearPairs < self
+      def test_gets_linear_pairs
+        exp = [
+          [[1, 6], [6, 2], [2, 5], [5, 11]],
+          [[3, 15], [15, 13], [13, 2], [2, 9]]
+        ]
+        assert_equal exp, @metric.send(:get_pairs, @v1, @v2)
+      end
+    end
+
+    class TestCombinatorialPairs < self
+      def setup
+        @pair = :combinatorial
+        super
+      end
+      def test_gets_combinatorial_pairs
+        exp = [
+          [[1, 6], [1, 2], [1, 5], [1, 11], [6, 2], [6, 5],
+            [6, 11], [2, 5], [2, 11], [5, 11]],
+          [[3, 15], [3, 13], [3, 2], [3, 9], [15, 13], [15, 2],
+            [15, 9], [13, 2], [13, 9], [2, 9]]
+        ]
+        assert_equal exp, @metric.send(:get_pairs, @v1, @v2)
+      end
+    end
+  end
+
+  class TestDeltas < self
+    class TestIntraDelta < self
+      def test_gets_intra_delta
+        pairs = [
+          [[1, 6], [6, 2], [2, 5], [5, 11]],
+          [[3, 15], [15, 13], [13, 2], [2, 9]]
+        ]
+        exp = [
+          [5, 4, 3, 6],
+          [12, 2, 11, 7]
+        ]
+        assert_equal exp, @metric.send(:intra_delta, pairs)
+      end
+      def test_intra_delta_proc
+        @metric.intra_delta = ->(*vp) {nil}
+        assert_instance_of Proc, @metric.instance_variable_get(:@intra_delta)
+      end
+    end
+
+    class TestInterDelta < self
+      def setup
+        super
+        @diffs = [
+          [5, 4, 3, 6],
+          [12, 2, 11, 7]
+        ]
+      end
+      def test_gets_inter_delta_ordered
+        exp = 4.5
+        assert_equal exp, @metric.send(:inter_delta, @diffs) 
+      end
+      def test_inter_delta_proc
+        @metric.inter_delta = ->(*diffs) {nil}
+        assert_instance_of Proc, @metric.instance_variable_get(:@inter_delta)
+      end
+    end
+  end
+
+  class TestScaling < self
+    def setup
+      super
+      @unscaled = [
+        [5, 4, 3, 6],
+        [12, 2, 11, 7]
+      ]
+    end
+
+    def test_assigns_scaling_proc
+      @metric.scale = ->(pairs) {}
+      scale = @metric.instance_variable_get :@scale
+      assert_equal Proc, scale.class 
+    end
+
+    def test_no_scaling
+      assert_equal @unscaled, @metric.send(:scale, @unscaled)
+    end
+
+    # TODO: This is a complicated test and I don't like it
+    def test_absolute_scaling
+      @metric.scale = :absolute
+      @exp = [
+        [0.417, 0.333, 0.25, 0.5],
+        [1.0, 0.167, 0.917, 0.583]
+      ]
+      actual = @metric.send :scale, @unscaled
+      actual.each_with_index do |v, i|
+        v.each_with_index do |w, j|
+          assert_in_delta @exp[i][j], w, 0.001 
+        end
+      end
+    end
+
+    def test_relative_scaling
+      @metric.scale = :relative
+      @exp = [
+        [0.833, 0.667, 0.5, 1.0],
+        [1.0, 0.167, 0.917, 0.583]
+      ]
+      actual = @metric.send :scale, @unscaled
+      actual.each_with_index do |v, i|
+        v.each_with_index do |w, j|
+          assert_in_delta @exp[i][j], w, 0.001 
+        end
+      end
+    end
+  end
+
+  class TestMagnitudeMetric < self
+    # Definitions of expected results
+    @exp = {
+      :olm => {:scale_none => 4.5, :scale_absolute => 0.375},
+      :ocm => {:scale_none => 5.2, :scale_absolute => 0.4},
+      :ulm => {:scale_none => 3.5, :scale_absolute => 0.29167},
+      :ucm => {:scale_none => 2.4, :scale_absolute => 0.1846},
+      :old => {:scale_none => 0.25},
+      :ocd => {:scale_none => 0.4},
+      :uld => {:scale_none => 0.25},
+      :ucd => {:scale_none => 0.4}
+    }
+
+    @exp.each do |metric, expected|
+      expected.each do |scaling, e|
+        define_method "test_#{metric}_#{scaling}" do
+          m = ::MM::Metric.se

data/test/mm/test_mm.rb

@@ -1,6 +1,5 @@
-require "minitest/autorun"
-require "mm"
-
-class TestMM < Minitest::Test
-
-end
+require "minitest/autorun"
+require "mm"
+
+class TestMM < Minitest::Test
+

data/test/mm/test_pairs.rb

@@ -1,27 +1,24 @@
-# require "minitest/autorun"
-require "mm/pairs"
-
-class TestMM < Minitest::Test; end
-
-class TestMM::TestPairs < Minitest::Test
-  def setup
-    @pairs = MM::Pairs.new
-  end
-
-  def test_linear_flat_array
-    assert_equal [[0, 1], [1, 2], [2, 3]], @pairs.linear([0, 1, 2, 3])
-  end
-
-  def test_linear_nested_array
-    assert_equal [[[0, 1], [2, 3]], [[2, 3], [4, 5]]], @pairs.linear([[0, 1], [2, 3], [4, 5]])
-  end
-
-  def test_combinatorial_flat_array
-    assert_equal [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]], @pairs.combinatorial([0, 1, 2, 3])
-  end
-  
-  def test_combinatorial_nested_array
-    assert_equal [[[0, 1], [2, 3]], [[0, 1], [4, 5]], [[2, 3], [4, 5]]], @pairs.combinatorial([[0, 1], [2, 3], [4, 5]])
-  end
-end
-
+# require "minitest/autorun"
+require "mm/pairs"
+
+class TestMM < Minitest::Test; end
+
+class TestMM::TestPairs < Minitest::Test
+  def setup
+    @pairs = MM::Pairs.new
+  end
+
+  def test_linear_flat_array
+    assert_equal [[0, 1], [1, 2], [2, 3]], @pairs.linear([0, 1, 2, 3])
+  end
+
+  def test_linear_nested_array
+    assert_equal [[[0, 1], [2, 3]], [[2, 3], [4, 5]]], @pairs.linear([[0, 1], [2, 3], [4, 5]])
+  end
+
+  def test_combinatorial_flat_array
+    assert_equal [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]], @pairs.combinatorial([0, 1, 2, 3])
+  end
+  
+  def test_combinatorial_nested_array
+    assert_equal [[[0, 1], [2, 3]], [[0, 1], [4, 5]], [[2, 3], [4, 5]]], @pairs.combinatorial([[0, 1], [2, 3

data/test/mm/test_ratio.rb

@@ -1,132 +1,130 @@
-require 'mm/ratio'
-
-class TestMM < Minitest::Test; end
-
-class TestMM::TestRatio < Minitest::Test
-  def setup
-    @ratio = MM::Ratio.new(3,2)
-  end
-
-  def test_numerator
-    assert_equal 3, @ratio.numerator
-  end
-
-  def test_denominator
-    assert_equal 2, @ratio.denominator
-  end
-
-  def test_multiplication
-    mul = @ratio * MM::Ratio.new(5,4)
-    assert_equal MM::Ratio.new(15,8), mul
-  end
-
-  def test_multiplication_reduces
-    mul = @ratio * MM::Ratio.new(10,9)
-    assert_equal MM::Ratio.new(5,3), mul
-  end
-
-  def test_division
-    div = @ratio / MM::Ratio.new(5,4)
-    assert_equal MM::Ratio.new(6,5), div
-  end
-
-  def test_from_s_single
-    assert_equal @ratio, MM::Ratio.from_s("3/2")
-  end
-
-  def test_from_s_array
-    assert_equal [@ratio, @ratio], MM::Ratio.from_s(%w(3/2 3/2))
-  end
-
-  def test_from_s_list
-    assert_equal [@ratio, @ratio], MM::Ratio.from_s("3/2 3/2")
-  end
-
-  def test_from_s_multi_digit
-    assert_equal MM::Ratio.new(10,9), MM::Ratio.from_s("10/9")
-  end
-
-  def test_to_f
-    assert_equal 1.5, @ratio.to_f
-  end
-
-  def test_to_s
-    assert_equal "3/2", @ratio.to_s
-  end
-
-  def test_eql
-    assert @ratio.eql?(MM::Ratio.new(3,2))
-  end
-
-  def test_uniq
-    assert_equal [MM::Ratio.new(3,2)], [MM::Ratio.new(3,2), @ratio].uniq
-  end
-
-  def test_plus
-    assert_equal MM::Ratio.new(3,1), @ratio + @ratio
-  end
-
-  def test_minus
-    assert_equal MM::Ratio.new(5,6), @ratio - @ratio.reciprocal
-  end
-
-  def test_reciprocal
-    assert_equal MM::Ratio.new(2,3), @ratio.reciprocal
-  end
-
-  def test_cents
-    assert_in_delta 701.955, @ratio.cents
-  end
-
-  def test_reads_ratios_from_yaml
-    ratios = MM::Ratio.from_yaml(<<-YAML)
-- 1/1
-- 10/9
-- 5/4
-    YAML
-    exp = [MM::Ratio.new(1,1), MM::Ratio.new(10,9), MM::Ratio.new(5,4)]
-    assert_equal exp, ratios
-  end
-
-  def test_to_vector
-    point = [MM::Ratio.new(1,1), MM::Ratio.new(3,2), MM::Ratio.new(5,4)]
-    exp = [MM::Ratio.new(2,3), MM::Ratio.new(6,5)]
-    assert_equal exp, MM::Ratio.to_vector(point)
-  end
-
-  def test_from_vector
-    vector = [MM::Ratio.new(2,3), MM::Ratio.new(6,5)]
-    exp = [MM::Ratio.new(1,1), MM::Ratio.new(3,2), MM::Ratio.new(5,4)]
-    assert_equal exp, MM::Ratio.from_vector(vector)
-  end
-
-  def test_change_interval
-    point = [MM::Ratio.new(1,1), MM::Ratio.new(3,2), MM::Ratio.new(5,4)]
-    exp = [MM::Ratio.new(1,1), MM::Ratio.new(4,3), MM::Ratio.new(10,9)]
-    assert_equal exp, MM::Ratio.change_interval(point, 0, MM::Ratio.new(3,4))
-  end
-
-  def test_change_interval_reciprocal
-    point = [MM::Ratio.new(1,1), MM::Ratio.new(3,2), MM::Ratio.new(5,4)]
-    exp = [MM::Ratio.new(1,1), MM::Ratio.new(2,3), MM::Ratio.new(5,9)]
-    assert_equal exp, MM::Ratio.change_interval(point, 0, :reciprocal)
-  end
-
-  def test_factors
-    assert_equal [[2, -1], [3, 1]], MM::Ratio.new(3,2).factors
-    assert_equal [[2, -1], [3, -1], [5, 1]], MM::Ratio.new(5,6).factors
-  end
-
-  def test_each
-    enumerator = MM::Ratio.new(3,2).each
-    assert_kind_of Enumerator, enumerator
-    assert_equal 3, enumerator.next
-    assert_equal 2, enumerator.next
-  end
-
-  def test_prime_limit
-    assert_equal 13, MM::Ratio.new(26,5).prime_limit
-    assert_equal nil, MM::Ratio.new(1,1).prime_limit
-  end
-end
-
+require 'mm/ratio'
+
+class TestMM < Minitest::Test; end
+
+class TestMM::TestRatio < Minitest::Test
+  def setup
+    @ratio = MM::Ratio.new(3,2)
+  end
+
+  def test_numerator
+    assert_equal 3, @ratio.numerator
+  end
+
+  def test_denominator
+    assert_equal 2, @ratio.denominator
+  end
+
+  def test_multiplication
+    mul = @ratio * MM::Ratio.new(5,4)
+    assert_equal MM::Ratio.new(15,8), mul
+  end
+
+  def test_multiplication_reduces
+    mul = @ratio * MM::Ratio.new(10,9)
+    assert_equal MM::Ratio.new(5,3), mul
+  end
+
+  def test_division
+    div = @ratio / MM::Ratio.new(5,4)
+    assert_equal MM::Ratio.new(6,5), div
+  end
+
+  def test_from_s_single
+    assert_equal @ratio, MM::Ratio.from_s("3/2")
+  end
+
+  def test_from_s_array
+    assert_equal [@ratio, @ratio], MM::Ratio.from_s(%w(3/2 3/2))
+  end
+
+  def test_from_s_list
+    assert_equal [@ratio, @ratio], MM::Ratio.from_s("3/2 3/2")
+  end
+
+  def test_from_s_multi_digit
+    assert_equal MM::Ratio.new(10,9), MM::Ratio.from_s("10/9")
+  end
+
+  def test_to_f
+    assert_equal 1.5, @ratio.to_f
+  end
+
+  def test_to_s
+    assert_equal "3/2", @ratio.to_s
+  end
+
+  def test_eql
+    assert @ratio.eql?(MM::Ratio.new(3,2))
+  end
+
+  def test_uniq
+    assert_equal [MM::Ratio.new(3,2)], [MM::Ratio.new(3,2), @ratio].uniq
+  end
+
+  def test_plus
+    assert_equal MM::Ratio.new(3,1), @ratio + @ratio
+  end
+
+  def test_minus
+    assert_equal MM::Ratio.new(5,6), @ratio - @ratio.reciprocal
+  end
+
+  def test_reciprocal
+    assert_equal MM::Ratio.new(2,3), @ratio.reciprocal
+  end
+
+  def test_cents
+    assert_in_delta 701.955, @ratio.cents
+  end
+
+  def test_reads_ratios_from_yaml
+    ratios = MM::Ratio.from_yaml(<<-YAML)
+- 1/1
+- 10/9
+- 5/4
+    YAML
+    exp = [MM::Ratio.new(1,1), MM::Ratio.new(10,9), MM::Ratio.new(5,4)]
+    assert_equal exp, ratios
+  end
+
+  def test_to_vector
+    point = [MM::Ratio.new(1,1), MM::Ratio.new(3,2), MM::Ratio.new(5,4)]
+    exp = [MM::Ratio.new(2,3), MM::Ratio.new(6,5)]
+    assert_equal exp, MM::Ratio.to_vector(point)
+  end
+
+  def test_from_vector
+    vector = [MM::Ratio.new(2,3), MM::Ratio.new(6,5)]
+    exp = [MM::Ratio.new(1,1), MM::Ratio.new(3,2), MM::Ratio.new(5,4)]
+    assert_equal exp, MM::Ratio.from_vector(vector)
+  end
+
+  def test_change_interval
+    point = [MM::Ratio.new(1,1), MM::Ratio.new(3,2), MM::Ratio.new(5,4)]
+    exp = [MM::Ratio.new(1,1), MM::Ratio.new(4,3), MM::Ratio.new(10,9)]
+    assert_equal exp, MM::Ratio.change_interval(point, 0, MM::Ratio.new(3,4))
+  end
+
+  def test_change_interval_reciprocal
+    point = [MM::Ratio.new(1,1), MM::Ratio.new(3,2), MM::Ratio.new(5,4)]
+    exp = [MM::Ratio.new(1,1), MM::Ratio.new(2,3), MM::Ratio.new(5,9)]
+    assert_equal exp, MM::Ratio.change_interval(point, 0, :reciprocal)
+  end
+
+  def test_factors
+    assert_equal [[2, -1], [3, 1]], MM::Ratio.new(3,2).factors
+    assert_equal [[2, -1], [3, -1], [5, 1]], MM::Ratio.new(5,6).factors
+  end
+
+  def test_each
+    enumerator = MM::Ratio.new(3,2).each
+    assert_kind_of Enumerator, enumerator
+    assert_equal 3, enumerator.next
+    assert_equal 2, enumerator.next
+  end
+
+  def test_prime_limit
+    assert_equal 13, MM::Ratio.new(26,5).prime_limit
+    assert_equal nil, MM::Ratio.new(1,1).prime_limit
+  en

data/test/mm/test_scaling.rb

@@ -10,18 +10,21 @@ class TestMM::TestScaling < Minitest::Test
     @n = [4, 3, 6, 2]
     @m = [3, 4, 1, 2]
   end
+
   def test_absolute_scaling
     expected = [[0.667, 0.5, 1.0, 0.333],
                 [0.5, 0.667, 0.167, 0.333]]
     result = MM::Scaling.absolute([@n, @m])
     assert_nested_in_delta_2_deep expected, result
   end
+
   def test_relative_scaling
     expected = [[0.667, 0.5, 1.0, 0.333],
                 [0.75, 1.0, 0.25, 0.5]]
     result = MM::Scaling.relative([@n, @m])
     assert_nested_in_delta_2_deep expected, result
   end
+
   def test_get_global_scaling
     expected = [[0.5, 0.375, 0.75, 0.25],
                 [0.375, 0.5, 0.125, 0.25]]