morphological_metrics 1.2.0 → 1.3.0

data/lib/mm/scaling.rb

@@ -1,27 +1,30 @@
-module MM
-  module Scaling
-    # All of these functions require a sequence of distance pair evaluations of
-    # the given metric. They all output scaled versions.
-
-    # Scale to the max across both vector
-    def self.none pairs
-      pairs
-    end
-    def self.absolute pairs
-      max = (pairs.map(&:max)).max
-      pairs.map {|x| x.map {|y| y.to_f / max}}
-    end
-    # Scale each vector to its own max
-    def self.relative pairs
-      maxes = pairs.map(&:max)
-      pairs.zip(maxes).map {|pair, max| pair.map {|x| x.to_f / max}}
-    end
-    # Note: a bit hacky. But anything starting with "get_" should be considered
-    # a meta-scaling method. This method returns a Proc that has a particular
-    # scaling value hard-coded into it, for re-use and re-use.
-    def self.get_global max
-      ->(pairs) {pairs.map {|x| x.map {|y| y.to_f / max}}}
-    end
-  end
-end
-
+module MM
+  module Scaling
+    # All of these functions require a sequence of distance pair evaluations of
+    # the given metric. They all output scaled versions.
+
+    # Scale to the max across both vector
+    def self.none pairs
+      pairs
+    end
+
+    def self.absolute pairs
+      max = (pairs.map(&:max)).max
+      pairs.map {|x| x.map {|y| y.to_f / max}}
+    end
+
+    # Scale each vector to its own max
+    def self.relative pairs
+      maxes = pairs.map(&:max)
+      pairs.zip(maxes).map {|pair, max| pair.map {|x| x.to_f / max}}
+    end
+
+    # Note: a bit hacky. But anything starting with "get_" should be considered
+    # a meta-scaling method. This method returns a Proc that has a particular
+    # scaling value hard-coded into it, for re-use and re-use.
+    def self.get_global max
+      ->(pairs) {pairs.map {|x| x.map {|y| y.to_f / max}}}
+    end
+  end
+end
+

data/lib/mm/search.rb

@@ -1,81 +1,81 @@
-module MM; end
-
-# All you need to do is add an adjacent_points_function and cost_function
-class MM::Search
-  attr_accessor :candidates, :delta, :starting_point, :path, :banned, :iterations
-  attr_writer :cost_function, :adjacent_points_function
-
-  def initialize starting_point, delta = 0.001
-    @starting_point = starting_point
-    @delta = delta
-    @current_point = @starting_point
-    @path = []
-    @banned = []
-    @iterations = 0
-  end
-
-  # Finds a vector beginning from the starting point
-  def find
-    find_from_point @starting_point
-  end
-
-  def find_from_point point
-    @iterations += 1
-    # The adjacent points are all sorted
-    # raise StopIteration if cost_function(point) > current_cost
-    add_to_path point
-    sorted_adjacent_points = get_sorted_adjacent_points
-    # If we've made it, return it.
-    if made_it?
-      @current_point
-    else
-      begin
-        find_from_point sorted_adjacent_points.next
-      rescue StopIteration => er
-        # When the list of adjacent points runs out, backtrack
-        backtrack
-        retry unless @current_point.nil?
-      end
-    end
-  end
-
-  def add_to_path point
-    @current_point = point
-    @path << point
-  end
-
-  def backtrack
-    @banned << @path.pop
-    puts "Path: #{@path.size}, Banned: #{@banned.size}" if ENV["DEBUG_RB"] && ENV["DEBUG_RB"].to_i > 1
-    @current_point = @path.last
-  end
-
-  def calculate_cost candidates
-    candidates.map {|x| cost_function x}
-  end
-
-  def made_it?
-    current_cost < @delta
-  end
-
-  def cost_function *args
-    @cost_function.call(*args)
-  end
-  
-  def current_cost
-    cost_function @current_point
-  end
- 
-  def get_adjacent_points *args
-    @adjacent_points_function.call(@current_point, *args)
-  end
-
-  def get_sorted_adjacent_points *args
-    get_adjacent_points(*args)
-      .reject {|c| @path.include? c}
-      .reject {|c| @banned.include? c}
-      .sort_by {|x| cost_function x}
-      .to_enum
-  end
-end
-
+module MM; end
+
+# All you need to do is add an adjacent_points_function and cost_function
+class MM::Search
+  attr_accessor :candidates, :delta, :starting_point, :path, :banned, :iterations
+  attr_writer :cost_function, :adjacent_points_function
+
+  def initialize starting_point, delta = 0.001
+    @starting_point = starting_point
+    @delta = delta
+    @current_point = @starting_point
+    @path = []
+    @banned = []
+    @iterations = 0
+  end
+
+  # Finds a vector beginning from the starting point
+  def find
+    find_from_point @starting_point
+  end
+
+  def find_from_point point
+    @iterations += 1
+    # The adjacent points are all sorted
+    # raise StopIteration if cost_function(point) > current_cost
+    add_to_path point
+    sorted_adjacent_points = get_sorted_adjacent_points
+    # If we've made it, return it.
+    if made_it?
+      @current_point
+    else
+      begin
+        find_from_point sorted_adjacent_points.next
+      rescue StopIteration => er
+        # When the list of adjacent points runs out, backtrack
+        backtrack
+        retry unless @current_point.nil?
+      end
+    end
+  end
+
+  def add_to_path point
+    @current_point = point
+    @path << point
+  end
+
+  def backtrack
+    @banned << @path.pop
+    puts "Path: #{@path.size}, Banned: #{@banned.size}" if ENV["DEBUG_RB"] && ENV["DEBUG_RB"].to_i > 1
+    @current_point = @path.last
+  end
+
+  def calculate_cost candidates
+    candidates.map {|x| cost_function x}
+  end
+
+  def made_it?
+    current_cost < @delta
+  end
+
+  def cost_function *args
+    @cost_function.call(*args)
+  end
+  
+  def current_cost
+    cost_function @current_point
+  end
+ 
+  def get_adjacent_points *args
+    @adjacent_points_function.call(@current_point, *args)
+  end
+
+  def get_sorted_adjacent_points *args
+    get_adjacent_points(*args)
+      .reject {|c| @path.include? c}
+      .reject {|c| @banned.include? c}
+      .sort_by {|x| cost_function x}
+      .to_enum
+  end
+end
+

data/lib/mm.rb

@@ -1,11 +1,10 @@
-module MM
-  VERSION = "1.2.0"
-end
-
-require 'mm/deltas'
-require 'mm/metric'
-require 'mm/pairs'
-require 'mm/ratio'
-require 'mm/scaling'
-require 'mm/search'
-
+module MM
+  VERSION = "1.2.0"
+end
+
+require 'mm/deltas'
+require 'mm/metric'
+require 'mm/pairs'
+require 'mm/ratio'
+require 'mm/scaling'
+require 'mm/

data/lib/shortcuts.yml

@@ -1,49 +1,49 @@
-:olm:
-  :ordered: true
-  :pair: :linear
-  :scale: :none
-  :intra_delta: :abs
-  :inter_delta: :abs
-:ocm:
-  :ordered: true
-  :pair: :combinatorial
-  :scale: :none
-  :intra_delta: :abs
-  :inter_delta: :abs
-:ulm:
-  :ordered: false
-  :pair: :linear
-  :scale: :none
-  :intra_delta: :abs
-  :inter_delta: :mean
-:ucm:
-  :ordered: false
-  :pair: :combinatorial
-  :scale: :none
-  :intra_delta: :abs
-  :inter_delta: :mean
-:old:
-  :ordered: true
-  :pair: :linear
-  :scale: :none
-  :intra_delta: :direction
-  :inter_delta: :abs
-:ocd:
-  :ordered: true
-  :pair: :combinatorial
-  :scale: :none
-  :intra_delta: :direction
-  :inter_delta: :abs
-:uld:
-  :ordered: false
-  :pair: :linear
-  :scale: :none
-  :intra_delta: :direction
-  :inter_delta: :mean
-:ucd:
-  :ordered: false
-  :pair: :combinatorial
-  :scale: :none
-  :intra_delta: :direction
-  :inter_delta: :mean
-
+:olm:
+  :ordered: true
+  :pair: :linear
+  :scale: :none
+  :intra_delta: :abs
+  :inter_delta: :abs
+:ocm:
+  :ordered: true
+  :pair: :combinatorial
+  :scale: :none
+  :intra_delta: :abs
+  :inter_delta: :abs
+:ulm:
+  :ordered: false
+  :pair: :linear
+  :scale: :none
+  :intra_delta: :abs
+  :inter_delta: :mean
+:ucm:
+  :ordered: false
+  :pair: :combinatorial
+  :scale: :none
+  :intra_delta: :abs
+  :inter_delta: :mean
+:old:
+  :ordered: true
+  :pair: :linear
+  :scale: :none
+  :intra_delta: :direction
+  :inter_delta: :abs
+:ocd:
+  :ordered: true
+  :pair: :combinatorial
+  :scale: :none
+  :intra_delta: :direction
+  :inter_delta: :abs
+:uld:
+  :ordered: false
+  :pair: :linear
+  :scale: :none
+  :intra_delta: :direction
+  :inter_delta: :mean
+:ucd:
+  :ordered: false
+  :pair: :combinatorial
+  :scale: :none
+  :intra_delta: :direction
+  :inter_delta: :mean
+

data/test/helpers.rb

@@ -1,22 +1,19 @@
-module TestHelpers
-  # Asserts that each item in exp matches each item in act
-  def assert_nested_in_delta exp, act, delta = 0.001, msg = nil 
-    exp.zip(act) do |x|
-      if block_given?
-        yield x, delta, msg
-      else
-        assert_in_delta(*x, delta, msg)
-      end
-    end
-  end
-
-  # Asserts that nested values 2-deep are within a certain delta
-  def assert_nested_in_delta_2_deep *args
-    assert_nested_in_delta(*args) do |x, delta, msg|
-      x[0].zip(x[1]) do |y|
-        assert_in_delta(*y, delta, msg)
-      end
-    end
-  end
-end
-
+module TestHelpers
+  # Asserts that each item in exp matches each item in act
+  def assert_nested_in_delta exp, act, delta = 0.001, msg = nil 
+    exp.zip(act) do |x|
+      if block_given?
+        yield x, delta, msg
+      else
+        assert_in_delta(*x, delta, msg)
+      end
+    end
+  end
+
+  # Asserts that nested values 2-deep are within a certain delta
+  def assert_nested_in_delta_2_deep *args
+    assert_nested_in_delta(*args) do |x, delta, msg|
+      x[0].zip(x[1]) do |y|
+        assert_in_delta(*y, delta, msg)
+      end
+ 

data/test/mm/test_deltas.rb

@@ -12,28 +12,33 @@ class TestMM::TestDeltas < Minitest::Test
     result = input.map {|x| MM::Deltas.abs(x)}
     assert_equal exp, result
   end
+
   def test_mean_inter_delta
     input = [[5, 4, 3, 6], [12, 2, 11, 7]]
     exp = [4.5, 8]
     result = input.map {|x| MM::Deltas.mean(x)}
     assert_equal exp, result
   end
+
   def test_distance_ordered_inter_delta
     input = [[-1, -1], [1, 1], [-1, 1], [-1, -1]]
     exp = [0, 0, 2, 0]
     result = input.map {|x| MM::Deltas.abs(x)}
     assert_equal exp, result
   end
+
   def test_tenney_ordered_intra_delta
     input = [[Rational(1,1), Rational(3,2)], [Rational(3,2), Rational(5,4)]]
     exp = [2.585, 4.907]
     assert_nested_in_delta exp, input.map {|x| MM::Deltas.tenney(x)}
   end
+
   def test_log_ratio_ordered_intra_delta
     input = [[Rational(1,1), Rational(3,2)], [Rational(3,2), Rational(5,4)]]
     exp = [0.585, 0.263]
     assert_nested_in_delta exp, input.map {|x| MM::Deltas.log_ratio(x)}
   end
+
   def test_ratio_ordered_intra_delta
     input = [[Rational(1,1), Rational(3,2)], [Rational(3,2), Rational(5,4)]]
     exp = [Rational(2,3), Rational(6,5)]