morphological_metrics 1.2.0 → 1.3.0

data/lib/mm/metric.rb

@@ -1,191 +1,180 @@
-require 'psych'
-
-module MM
-  class Metric
-    # Constructor for the Metric object.
-    #
-    # ordered - [Boolean] 
-    #   Controls whether metric is ordered
-    # pair - [Symbol, #call] 
-    #   Method of +MM::Deltas+, or where +Object#call+ returns an +Array+ of
-    #   pairs.
-    # scale - [Symbol, #call] 
-    #   Method of +MM::Scaling+, or where +Object#call+ returns a scaled diff
-    #   +Array+
-    # intra_delta - [Symbol, #call] 
-    #   Method of +MM::Deltas+, or where +Object#call+ returns +Array+ of
-    #   differences between pairs of elements
-    # inter_delta - [Symbol, #call] 
-    #   Method of +MM::Deltas+, or where +Object#call+ returns +Array+ of
-    #   differences between the diffs of the two input morphologies
-    # 
-    def initialize(ordered: true, pair: nil, scale: nil, intra_delta: nil, inter_delta: nil)
-      @ordered = ordered
-      self.pair = pair
-      self.scale = scale
-      self.intra_delta = intra_delta
-      self.inter_delta = inter_delta
-    end
-
-    attr_accessor :ordered
-
-    # Public: Gets the distance between two vectors, according to the Metric
-    # object. Since +Metric+ can be duck-typed to work with +intra_delta+ and
-    # +inter_delta+, it should be possible to nest +Metric+ objects.
-    #
-    # v1 - The vector to call on.
-    # v2 - The vector to compare against.
-    #
-    # Returns a [Float] distance between the two vectors.
-    def call v1, v2
-      # "Readable" method provided for the parenthetically inclined
-      # inter_delta(scale(intra_delta(get_pairs(v1, v2))))
-      inter_delta scale intra_delta get_pairs v1, v2
-    end
-
-    # Public: Setter method for pair.
-    #
-    # pair - [Symbol, #call] 
-    #   Method of +MM::Deltas+, or where +Object#call+ returns an +Array+ of
-    #   pairs.
-    #
-    # Returns a [Proc] pair.
-    def pair= pair
-      protected_use_method(MM::Pairs.new, :@pair, pair)
-    end
-
-    # Public: Setter method for scale.
-    #
-    # scale - Either a Proc that can process scaling, or a Symbol to look up in
-    #   MM::Scaling.
-    #
-    # Returns scale.
-    def scale= scale
-      protected_use_method(MM::Scaling, :@scale, scale)
-    end
-
-    # Public: Setter method for intra_delta.
-    #
-    # intra_delta - Either a Proc that can process the intra_delta, or a Symbol
-    #   to look up in MM::Deltas.
-    #
-    # Returns intra_delta.
-    def intra_delta= intra_delta
-      protected_use_method(MM::Deltas, :@intra_delta, intra_delta)
-    end
-
-    # Public: Setter method for inter_delta.
-    #
-    # inter_delta - Either a Proc that can process as an inter_delta, or a
-    #   Symbol where +MM::Deltas.respond_to? Symbol == true+
-    #
-    # Returns itself. Sets the instance variable @inter_delta.
-    def inter_delta= inter_delta
-      protected_use_method(MM::Deltas, :@inter_delta, inter_delta)
-    end
-
-    private
-
-    # Private: Calls the get_pairs Proc on each of v1 and v2. In lp's
-    # terminology, the get_pairs Proc should return either adjacent  pairs
-    # of each of the two vectors (for linear metrics) or all possible pair
-    # combinations (for combinatorial metrics). For more, see Polansky 1992.
-    # 
-    # v1 - the metric to use as a base
-    # v2 - the metric to compare to
-    #
-    # Returns an Array of Arrays of pairs.
-    def get_pairs v1, v2
-      [v1, v2].map {|x| @pair.call(x)}
-    end
-
-    # Private: Applies the delta to each pair of elements in a collection
-    # where each pair is [elem1, elem2]
-    # 
-    # vp - vector pairs
-    #
-    # Returns the vector_deltas, which is the difference between each pair of
-    # elements in a given vector.
-    def intra_delta vp
-      vp.map {|x| x.map {|n| @intra_delta.call(n)}}
-    end
-
-    # Private: Calls the scaling Proc. It's a Method, so if you want to subclass it when
-    # subclassing Metric (in order to do something fast and crazy) you totally can.
-    #
-    # pairs - A sequence of pairs.
-    #
-    # Returns the output of the scaling Proc, ideally a sequence of pairs.
-    def scale pairs
-      @scale.call pairs
-    end
-
-    # Private: Accepts a series of vectors, either a sequence of pairs or two full
-    # collections, and reduces them to a single vector. Does not do any scaling.
-    #
-    # diffs - [Enumerable] Series of vectors, either a sequence of pairs or two full
-    #   collections.
-    #
-    # Returns a single vector of the diffs between the two.
-    def inter_delta diffs
-      if @ordered
-        # Ordered Metrics take the mean of differences
-        Deltas.mean(diffs[0].zip(diffs[1]).map {|x| @inter_delta.call x})
-      else
-        # Unordered Metrics take the difference of means
-        Deltas.abs(diffs.map {|x| @inter_delta.call x})
-      end
-    end
-
-    # Private: Performs final averaging on the output of inter_delta. Can be overwritten
-    # when subclassed, in case you want to use a different method of averaging
-    # (sum of squares, etc.)
-    #
-    # diffs - The vector of the differences between the two vector deltas. Essentially 
-    #   the output of inter_delta. Should respond to #reduce.
-    #
-    # Returns distance [Numeric] The distance calculated by the diff
-    def post_scale diffs
-      diffs.reduce(0, :+).to_f / diffs.size
-    end
-
-    # Private: Assigns the Method named sym, if mod responds to it, to the
-    # instance variable var. Otherwise, assumes that the sym is actually a Proc
-    # and just tries to use it straight.
-    #
-    # mod - Object to see whether it has a method.
-    # var - instance variable to assign to.
-    # sym - Symbol to lookup in mod's exposed methods.
-    #
-    # Returns +sym+.
-    def protected_use_method mod, var, sym
-      if sym.is_a?(Symbol) && mod.respond_to?(sym)
-        self.instance_variable_set(var, mod.method(sym))
-      else
-        self.instance_variable_set(var, sym)
-      end
-    end
-
-    ### CONVENIENCE CREATION METHODS ###
-    # All of the following methods are created using the YAML definition file.
-    # See shortcuts.yml for the full definition.
-    # ::olm
-    # ::ocm
-    # ::ulm
-    # ::ucm
-    # ::old
-    # ::ocd
-    # ::uld
-    # ::ucd
-    METHOD_SHORTCUTS = Psych.load(File.read(File.join(File.dirname(__FILE__), '..', 'shortcuts.yml')))
-
-    class << self
-      METHOD_SHORTCUTS.each do |k, v|
-        define_method k do |other = {}|
-          new((v.merge other))
-        end
-      end
-    end
-  end
-end
-
+require 'psych'
+
+module MM
+  class Metric
+    # Constructor for the Metric object.
+    #
+    # ordered - [Boolean] 
+    #   Controls whether metric is ordered
+    # pair - [Symbol, #call] 
+    #   Method of +MM::Deltas+, or where +Object#call+ returns an +Array+ of
+    #   pairs.
+    # scale - [Symbol, #call] 
+    #   Method of +MM::Scaling+, or where +Object#call+ returns a scaled diff
+    #   +Array+
+    # intra_delta - [Symbol, #call] 
+    #   Method of +MM::Deltas+, or where +Object#call+ returns +Array+ of
+    #   differences between pairs of elements
+    # inter_delta - [Symbol, #call] 
+    #   Method of +MM::Deltas+, or where +Object#call+ returns +Array+ of
+    #   differences between the diffs of the two input morphologies
+    # 
+    def initialize(ordered: true, pair: nil, scale: nil, intra_delta: nil, inter_delta: nil)
+      @ordered = ordered
+      self.pair = pair
+      self.scale = scale
+      self.intra_delta = intra_delta
+      self.inter_delta = inter_delta
+    end
+
+    attr_accessor :ordered
+
+    # Public: Gets the distance between two vectors, according to the Metric
+    # object. Since +Metric+ can be duck-typed to work with +intra_delta+ and
+    # +inter_delta+, it should be possible to nest +Metric+ objects.
+    #
+    # v1 - The vector to call on.
+    # v2 - The vector to compare against.
+    #
+    # Returns a [Float] distance between the two vectors.
+    def call v1, v2
+      # "Readable" method provided for the parenthetically inclined
+      # inter_delta(scale(intra_delta(get_pairs(v1, v2))))
+      inter_delta scale intra_delta get_pairs v1, v2
+    end
+
+    # Public: Setter method for pair.
+    #
+    # pair - [Symbol, #call] 
+    #   Method of +MM::Deltas+, or where +Object#call+ returns an +Array+ of
+    #   pairs.
+    #
+    # Returns a [Proc] pair.
+    def pair= pair
+      protected_use_method(MM::Pairs.new, :@pair, pair)
+    end
+
+    # Public: Setter method for scale.
+    #
+    # scale - Either a Proc that can process scaling, or a Symbol to look up in
+    #   MM::Scaling.
+    #
+    # Returns scale.
+    def scale= scale
+      protected_use_method(MM::Scaling, :@scale, scale)
+    end
+
+    # Public: Setter method for intra_delta.
+    #
+    # intra_delta - Either a Proc that can process the intra_delta, or a Symbol
+    #   to look up in MM::Deltas.
+    #
+    # Returns intra_delta.
+    def intra_delta= intra_delta
+      protected_use_method(MM::Deltas, :@intra_delta, intra_delta)
+    end
+
+    # Public: Setter method for inter_delta.
+    #
+    # inter_delta - Either a Proc that can process as an inter_delta, or a
+    #   Symbol where +MM::Deltas.respond_to? Symbol == true+
+    #
+    # Returns itself. Sets the instance variable @inter_delta.
+    def inter_delta= inter_delta
+      protected_use_method(MM::Deltas, :@inter_delta, inter_delta)
+    end
+
+    private
+
+    # Private: Calls the get_pairs Proc on each of v1 and v2. In lp's
+    # terminology, the get_pairs Proc should return either adjacent  pairs
+    # of each of the two vectors (for linear metrics) or all possible pair
+    # combinations (for combinatorial metrics). For more, see Polansky 1992.
+    # 
+    # v1 - the metric to use as a base
+    # v2 - the metric to compare to
+    #
+    # Returns an Array of Arrays of pairs.
+    def get_pairs v1, v2
+      [v1, v2].map {|x| @pair.call(x)}
+    end
+
+    # Private: Applies the delta to each pair of elements in a collection
+    # where each pair is [elem1, elem2]
+    # 
+    # vp - vector pairs
+    #
+    # Returns the vector_deltas, which is the difference between each pair of
+    # elements in a given vector.
+    def intra_delta vp
+      vp.map {|x| x.map {|n| @intra_delta.call(n)}}
+    end
+
+    # Private: Calls the scaling Proc. It's a Method, so if you want to subclass it when
+    # subclassing Metric (in order to do something fast and crazy) you totally can.
+    #
+    # pairs - A sequence of pairs.
+    #
+    # Returns the output of the scaling Proc, ideally a sequence of pairs.
+    def scale pairs
+      @scale.call pairs
+    end
+
+    # Private: Accepts a series of vectors, either a sequence of pairs or two full
+    # collections, and reduces them to a single vector. Does not do any scaling.
+    #
+    # diffs - [Enumerable] Series of vectors, either a sequence of pairs or two full
+    #   collections.
+    #
+    # Returns a single vector of the diffs between the two.
+    def inter_delta diffs
+      if @ordered
+        # Ordered Metrics take the mean of differences
+        Deltas.mean(diffs[0].zip(diffs[1]).map {|x| @inter_delta.call x})
+      else
+        # Unordered Metrics take the difference of means
+        Deltas.abs(diffs.map {|x| @inter_delta.call x})
+      end
+    end
+
+    # Private: Performs final averaging on the output of inter_delta. Can be overwritten
+    # when subclassed, in case you want to use a different method of averaging
+    # (sum of squares, etc.)
+    #
+    # diffs - The vector of the differences between the two vector deltas. Essentially 
+    #   the output of inter_delta. Should respond to #reduce.
+    #
+    # Returns distance [Numeric] The distance calculated by the diff
+    def post_scale diffs
+      diffs.reduce(0, :+).to_f / diffs.size
+    end
+
+    # Private: Assigns the Method named sym, if mod responds to it, to the
+    # instance variable var. Otherwise, assumes that the sym is actually a Proc
+    # and just tries to use it straight.
+    #
+    # mod - Object to see whether it has a method.
+    # var - instance variable to assign to.
+    # sym - Symbol to lookup in mod's exposed methods.
+    #
+    # Returns +sym+.
+    def protected_use_method mod, var, sym
+      if sym.is_a?(Symbol) && mod.respond_to?(sym)
+        self.instance_variable_set(var, mod.method(sym))
+      else
+        self.instance_variable_set(var, sym)
+      end
+    end
+
+    ### CONVENIENCE CREATION METHODS ###
+    # All of the following methods are created using the YAML definition file.
+    # See shortcuts.yml for the full definition.
+    # ::olm
+    # ::ocm
+    # ::ulm
+    # ::ucm
+    # ::old
+    # ::ocd
+    # ::uld
+    # ::ucd
+    METHOD_SHORTCUTS = Psych.load(File.read(File.join(File.dirname(__FILE__), '..', 'shortcut

data/lib/mm/pairs.rb

@@ -1,11 +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,148 +1,145 @@
-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
-
+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
+