morphological_metrics 1.1.0

data/lib/mm/ratio.rb

@@ -0,0 +1,148 @@
+require 'yaml'
+require 'prime'
+
+module MM; end
+
+class MM::Ratio
+  include Comparable
+  include Enumerable
+
+  def initialize n, d
+    gcd = n.gcd d
+    @numerator = n / gcd
+    @denominator = d / gcd
+  end
+
+  attr_accessor :numerator, :denominator
+
+  def * other
+    MM::Ratio.new(self.numerator * other.numerator, self.denominator * other.denominator)
+  end
+
+  def / other
+    self * other.reciprocal
+  end
+
+  def + other
+    MM::Ratio.new(self.numerator*other.denominator + other.numerator*self.denominator,
+                  self.denominator*other.denominator)
+  end
+
+  def - other
+    self + (other * MM::Ratio.new(-1,1))
+  end
+
+  # Works very similarly to the Prime::prime_division method, except that
+  # factors in the numerator are positive, and factors in the denominator are
+  # negative.
+  def factors
+    n_factors = ::Prime.prime_division(@numerator)
+    d_factors = ::Prime.prime_division(@denominator).map {|d| d[1] *= -1; d}
+    n_factors.concat(d_factors).sort_by {|x| x[0]}
+  end
+
+  def abs
+    if self < MM::Ratio.new(0, 1)
+      self * MM::Ratio.new(-1,1)
+    else
+      self
+    end
+  end
+
+  def <=> other
+    # Ensure that the comparison makes sense
+    return nil unless other.respond_to? :-
+
+    case
+    when (self - other).to_f > 0
+      return 1
+    when (self - other).to_f < 0
+      return -1
+    end
+    return 0
+  end
+
+  def eql? other
+    other.is_a?(MM::Ratio) && (self == other)
+  end
+
+  def hash
+    [@numerator, @denominator, MM::Ratio].hash
+  end
+
+  def cents
+    Math.log2(self.to_f) * 1200.0
+  end
+
+  def self.from_s r
+    if r.respond_to? :split
+      if r =~ /\s/
+        r.split(/\s/).inject([]) {|memo, ratio|
+          memo << self.from_s(ratio)
+        }
+      else
+        string_to_ratio r
+      end
+    else
+      r.map {|s| self.from_s s}
+    end
+  end
+
+  def self.string_to_ratio string
+    m = string.match(/(\d+)\/(\d+)/)
+    MM::Ratio.new(m[1].to_i, m[2].to_i)
+  end
+
+  # Loads a sequence of MM::Ratios from a YAML file.
+  def self.from_yaml yaml_string
+    YAML.load(yaml_string).map {|r| MM::Ratio.from_s r}
+  end
+
+  def to_f
+    @numerator.to_f / @denominator
+  end
+
+  def to_s
+    "#{@numerator}/#{@denominator}"
+  end
+
+  def reciprocal
+    MM::Ratio.new(@denominator, @numerator)
+  end
+
+  def prime_limit
+    self.map { |r|
+      r.prime_division.map { |s|
+        s.first
+      }.max
+    }.compact.max
+  end
+
+  def each
+    if block_given?
+      [@numerator, @denominator].each do |r|
+        yield r
+      end
+    else
+      [@numerator, @denominator].each
+    end
+  end
+
+  def self.to_vector point
+    point.each_cons(2).map {|r| r[0] / r[1]}
+  end
+
+  def self.from_vector vector
+    vector.inject([MM::Ratio.new(1,1)]) {|m, r| m << (m.last / r)}
+  end
+
+  def self.change_interval point, index, interval
+    vector = MM::Ratio.to_vector(point)
+    if interval == :reciprocal
+      interval = vector[index].reciprocal
+    end
+    vector[index] = interval
+    MM::Ratio.from_vector(vector)
+  end
+end
+

data/lib/mm/scaling.rb

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,97 @@
+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
+  #   if cost_function(point) < current_cost
+  #     add_to_path point
+  #     if made_it?
+  #       return @current_point
+  #     else
+  #       get_sorted_adjacent_points.each do |possible_point|
+  #         find_from_point possible_point
+  #       end
+  #     end
+  #   else
+  #     backtrack
+  #   end
+  # 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

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

data/lib/shortcuts.yml

@@ -0,0 +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
+

data/test/helpers.rb

@@ -0,0 +1,22 @@
+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
+

data/test/mm/test_deltas.rb

@@ -0,0 +1,43 @@
+require 'mm/deltas'
+require_relative '../helpers.rb'
+
+class TestMM < Minitest::Test; end
+
+class TestMM::TestDeltas < Minitest::Test
+  include TestHelpers
+
+  def test_abs_ordered_inter_delta
+    input = [[5, 12], [4, 2], [3, 11], [6, 7]]
+    exp = [7, 2, 8, 1]
+    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)]
+    assert_nested_in_delta exp, input.map {|x| MM::Deltas.ratio(x)}
+  end
+end
+

data/test/mm/test_metric.rb

@@ -0,0 +1,168 @@
+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
+

data/test/mm/test_mm.rb

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

data/test/mm/test_pairs.rb

@@ -0,0 +1,27 @@
+# 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
+