morphological_metrics 1.3.0 → 1.3.1

data/lib/mm/pairs.rb

@@ -1,12 +1,12 @@
-module MM
-  class Pairs
-    def linear vector
-      vector.each_cons(2).to_a
-    end
-
-    def combinatorial vector
-      vector.combination(2).to_a
-    end
-  end
-end
-
+module MM
+  class Pairs
+    def linear vector
+      vector.each_cons(2).to_a
+    end
+
+    def combinatorial vector
+      vector.combination(2).to_a
+    end
+  end
+end
+

data/lib/mm/ratio.rb

@@ -1,145 +1,156 @@
-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
-  
+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
+
+  def [] i
+    if i == 0
+      self.numerator
+    elsif i == 1
+      self.denominator
+    end
+  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

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