morphological_metrics 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38630c4a00ff6c2cbe5dedbc373d664d6b4f33b6
+  data.tar.gz: 5e78dfc1aacd53e528215819c0fe6d8bd30bc2b6
+SHA512:
+  metadata.gz: 1d24565d2115f43919ae9ca4960225555f991cfa97edbe5bf07534fbd038f88f929283f2025e572cab51aa542765412cdc0d7bf028dad31c25d3abfc81461ae6
+  data.tar.gz: 0ddbb32a053f6ad71e70eea8390df5570f979b0ee197e3589874cc02980777dec04dce5e19bc171b54ef445f9e29c9ca2989f942c5315fec199a88f12a29ad98

data/.autotest

@@ -0,0 +1,30 @@
+# -*- ruby -*-
+
+require "autotest/restart"
+
+Autotest.add_hook :initialize do |at|
+  at.testlib = ".minitest"
+#
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception "vendor"
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end
+
+Autotest.add_hook :all_good do |at|
+  system "rake rcov_info"
+end if ENV['RCOV']
+

data/.minitest.rb

@@ -0,0 +1,3 @@
+gem "minitest"
+require "minitest/autorun"
+

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+env: 
+  - CODECLIMATE_REPO_TOKEN=d05b64cdc405df4f1632a3656a1062ea4873a20ff4463732c47c4d811884fde6 
+rvm:
+  - "2.0.0"
+  - "2.1.2"
+addons:
+  code_climate:
+    repo_token: d05b64cdc405df4f1632a3656a1062ea4873a20ff4463732c47c4d811884fde6  
+

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+gem 'hoe-travis'
+gem 'rake'
+gem 'rake-compiler'
+gem 'hoe'
+
+group :test do
+  gem 'minitest', '~> 5.0'
+  gem 'codeclimate-test-reporter', require: nil
+end
+
+group :development do
+  gem 'flog'
+  gem 'flay'
+end
+

data/Gemfile.lock

@@ -0,0 +1,48 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    codeclimate-test-reporter (0.3.0)
+      simplecov (>= 0.7.1, < 1.0.0)
+    docile (1.1.5)
+    flay (2.5.0)
+      ruby_parser (~> 3.0)
+      sexp_processor (~> 4.0)
+    flog (4.2.1)
+      ruby_parser (~> 3.1, > 3.1.0)
+      sexp_processor (~> 4.4)
+    hashr (0.0.22)
+    hoe (3.12.0)
+      rake (>= 0.8, < 11.0)
+    hoe-travis (1.2)
+      hoe (~> 3.0)
+      travis-lint (~> 1.2)
+    minitest (5.4.0)
+    multi_json (1.10.1)
+    rake (10.3.2)
+    rake-compiler (0.9.2)
+      rake
+    ruby_parser (3.6.1)
+      sexp_processor (~> 4.1)
+    safe_yaml (0.9.7)
+    sexp_processor (4.4.3)
+    simplecov (0.8.2)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    travis-lint (1.8.0)
+      hashr (~> 0.0.22)
+      safe_yaml (~> 0.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  codeclimate-test-reporter
+  flay
+  flog
+  hoe
+  hoe-travis
+  minitest (~> 5.0)
+  rake
+  rake-compiler

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2014-04-09
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,27 @@
+.autotest
+.minitest.rb
+.travis.yml
+Gemfile
+Gemfile.lock
+History.txt
+Manifest.txt
+README.rdoc
+ROADMAP.txt
+Rakefile
+bin/mm
+lib/mm.rb
+lib/mm/deltas.rb
+lib/mm/metric.rb
+lib/mm/pairs.rb
+lib/mm/ratio.rb
+lib/mm/scaling.rb
+lib/mm/search.rb
+lib/shortcuts.yml
+test/helpers.rb
+test/mm/test_deltas.rb
+test/mm/test_metric.rb
+test/mm/test_mm.rb
+test/mm/test_pairs.rb
+test/mm/test_ratio.rb
+test/mm/test_scaling.rb
+test/mm/test_search.rb

data/README.rdoc

@@ -0,0 +1,66 @@
+{<img src="https://codeclimate.com/github/andrewcsmith/mm.png"
+/>}[https://codeclimate.com/github/andrewcsmith/mm]
+
+{<img src="https://travis-ci.org/andrewcsmith/mm.svg?branch=master"
+/>}[https://travis-ci.org/andrewcsmith/mm]
+
+= mm
+
+https://www.github.com/andrewcsmith/mm
+
+== DESCRIPTION:
+
+Implements some Morphological Metrics, described by Larry Polansky.
+
+== FEATURES/PROBLEMS:
+
+* Works on anything Enumerable
+* Can get a number of different MMs
+* Works extra fast on large NMatrix objects
+
+== SYNOPSIS:
+
+Code sample, LOL
+
+== REQUIREMENTS:
+
+* nmatrix
+* ruby
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2014 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ROADMAP.txt

@@ -0,0 +1,63 @@
+- Complete functions for getting combinatorial and adjacent pairs
+	- fix any problems with shapes, test more thoroughly
+	- add the ability to recurse throughout an Array tree 
+- Create a selection of distance functions that work with NMatrix etc
+- These should be implementation-agnostic
+- Ideally they should be of the symbol/method format, where the user passes a
+  symbol of the method to the metric
+- Create a Metric class, perhaps as a subclass of Proc
+- What does it mean to subclass Proc?
+- Do some research.
+	- What about subclassing Method? What would that give us?
+- Instead of a "factory" class, the creation of the metric should take place in
+  its initialization. 
+	- Metric.new should take arguments similar to DistConfig, but with a
+	  specific implementation of OLM, OCM, etc. 
+	- This is out of a desire to tie the selection of the logic into the
+	  distance function.
+	- However, there could be MM.ocm, MM.olm, etc., functions that are
+	  "factories" that call the normal instantiation method. But it should
+not be possible to create a metric without the DistConfig in instantiation.
+
+Implementation and interface requirements:
+- Objects should implement [] and #each
+- Objects should implement whatever distance method is called by the Metric
+
+Additional distance functions should (ideally) be in their own gems.
+
+== Metric Class Methods 
+
+=== ::new(ordering, pairing, scaling, delta) 
+
+Generates a new morphological metric based on various parameters
+
+**ordered**: can be true or false. Corresponds to ordered/unordered.
+
+**pairing**: Similar to the delta. If it is a Proc, then the pairing function is
+called on each vector (or however it is handled by the ordering). If it is a
+Symbol, then we look it up in MM::PAIRING_FUNCTIONS.
+
+**scaling**: *always* a Proc. There are prebaked scaling functions for absolute,
+relative, and unscaled that are available for use. If a Symbol is passed instead
+of a Proc, it looks for the Proc in the Hash MM::SCALING_FUNCTIONS
+
+**delta functions**: If it is a Proc, then the delta function is used as d(x, y)
+on each element. If it is a symbol, then the symbol is first looked up in the
+MM::DELTA_FUNCTIONS hash. If it is not found, then x.symbol(y) is attempted.
+Delta functions should aspire to being as general as possible; let the source
+implement the method.
+
+**order**: this is confusing terminology - first-order and second-order
+difference functions.
+
+**interval functions**: We should instead brew the int_func into the method of
+finding pairs. This is where the Pairs class might come in handy; it could
+generate functions (Procs, whatever) as a factory from various values, taking
+into account what each value should be compared to. It's not [element, element],
+but [element, comparison-element] that matters.
+
+=== ::olm(scaling, delta) 
+
+Generates a new morphological metric calling ::new with the given ordering and
+pairing
+

data/Rakefile

@@ -0,0 +1,32 @@
+# -*- ruby -*-
+
+require "rubygems"
+require "hoe"
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :racc
+# Hoe.plugin :rcov
+Hoe.plugin :flay
+Hoe.plugin :flog
+
+Hoe.plugin :travis
+Hoe.plugin :inline
+Hoe.plugin :minitest
+Hoe.plugin :package
+
+hoe = Hoe.spec "morphological_metrics" do |h|
+  developer("Andrew C. Smith", "andrewchristophersmith@gmail.com")
+  license "MIT" # this should match the license in the README
+  self.readme_file = "README.rdoc"
+  require_rubygems_version '>= 1.4'
+end
+
+if ENV['CODECLIMATE_REPO_TOKEN']
+  hoe.test_prelude = <<CC
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+CC
+end
+
+# vim: syntax=ruby

data/bin/mm

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+abort "you need to write me"

data/lib/mm/deltas.rb

@@ -0,0 +1,35 @@
+module MM
+  module Deltas
+    def self.abs n
+      (n[0] - n[1]).abs
+    end
+
+    def self.diff n
+      n[0] - n[1]
+    end
+
+    def self.mean n
+      n.inject(0.0, :+) / n.size
+    end
+
+    # Have to scale by 0.5 in order to normalize to a max distance of 1.0
+    def self.direction n
+      (n[0] <=> n[1]) * 0.5
+    end
+
+    # Accepts a tuple where the quotient responds to #numerator and #denominator
+    def self.tenney n
+      ->(r) { Math.log2(r.numerator * r.denominator) }.call(n[0] / n[1])
+    end
+
+    # Accepts a tuple of anything that Math.log2 can handle
+    def self.log_ratio n
+      Math.log2((n[0] / n[1]).to_f).abs
+    end
+
+    def self.ratio n
+      n[0] / n[1]
+    end
+  end
+end
+

data/lib/mm/metric.rb

@@ -0,0 +1,191 @@
+require 'yaml'
+
+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 = YAML.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
+

data/lib/mm/pairs.rb

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