morphological_metrics-space 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6b4ccee2a0992b0630c278981be1f22d28957d3
+  data.tar.gz: 9d327612b6dfc66f2475a07d339a721da5943180
+SHA512:
+  metadata.gz: 9a6cdde119aeccb5e9db51c697175069a0b81b7da048bfa68d67937e8a252570f0838a3964fc5464746ed926e3330502523e7fba18e5dc464dcbe002e16122b5
+  data.tar.gz: 3d49b156895b5f2faa6a6a3e0187c526ea2d91e390a2ac13ca309467795f63b0d728ebed17d15da66e7edc14c27717f51e88a9f67dc76138eba75655bfa5d409

data/.autotest

@@ -0,0 +1,25 @@
+# -*- ruby -*-
+
+require "autotest/restart"
+
+# Autotest.add_hook :initialize do |at|
+#   at.testlib = "minitest/unit"
+#
+#   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

data/History.txt

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

data/Manifest.txt

@@ -0,0 +1,8 @@
+.autotest
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+bin/mm_space
+lib/mm/space.rb
+test/mm/test_space.rb

data/README.rdoc

@@ -0,0 +1,76 @@
+= mm-space
+
+* http://www.github.com/andrewcsmith/mm-space
+
+== DESCRIPTION:
+
+MM::Space is a framework for working with Morphological Metrics and
+Morphological Mutations in Ruby. A core component of MM::Space is that it has a
+notion of global distance throughout a series of measurements or
+transformations. This is what "Space" implies. It uses coworker libraries
+MM::Metric and MM::Mutation to drive these measurements and transformations.
+
+== FEATURES/PROBLEMS:
+
+* Nothing is implemented. (Does this qualify as a "FEATURE" or a "PROBLEM"? We
+  will never know.) 
+
+== SYNOPSIS:
+
+See bin/mm_space for a full example implementation (with comments)
+
+    x = MM::Metric.olm intra_delta: :tenney, inter_delta: :abs
+    y = MM::Metric.olm intra_delta: :ratio, inter_delta: :abs
+    space = Space.new [x, y]
+    distances = [[0.1, -0.1], [0.2, -0.2], [0.3, -0.3]]
+    start = %w(1/1 5/4 3/2 8/7 9/8).map {|x| MM::Ratio.from_s(x)}
+    space.enter do |s|
+      morph start, to: distances.each
+      morph start, to: distances.each, threads: 4
+      # Change some parameter of the space
+      s.lowest = start.map {|x| MM::Ratio.from_s("8/1")}
+      # Etc. etc...
+    end
+
+== REQUIREMENTS:
+
+* MM
+* MM::Metric
+* MM::Ratio
+
+== INSTALL:
+
+* Will fix when I get this all implemented
+
+== 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 

data/Rakefile

@@ -0,0 +1,24 @@
+# -*- ruby -*-
+
+require "rubygems"
+require "hoe"
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+Hoe.plugin :minitest
+# Hoe.plugin :racc
+# Hoe.plugin :rcov
+# Hoe.plugin :rdoc
+# Hoe.plugin :travis
+
+Hoe.spec "morphological_metrics-space" do
+  developer("Andrew Smith", "andrewchristophersmith@gmail.com")
+
+  # self.group_name = "mm-space" # if part of an organization/group
+  self.readme_file = "README.rdoc"
+  require_rubygems_version '>= 1.4'
+  license "MIT" # this should match the license in the README
+end
+
+# vim: syntax=ruby

data/bin/mm_space

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+#
+# # MM::Space
+# 
+# ## What is MM::Space? 
+# 
+# MM::Space is a framework for working with Morphological Metrics and
+# Morphological Mutations in Ruby. A core component of MM::Space is that it has
+# a notion of global distance throughout a series of measurements or
+# transformations. This is what "Space" implies. It uses coworker libraries
+# MM::Metric and MM::Mutation to drive these measurements and transformations.
+#
+# ## What does MM::Space do?
+#
+# MM::Space measures and transforms morphologies. You define *n* dimensions
+# (usually in metric space) and MM::Space will help you take measurements that
+# take all these dimensions into account. In this sense, it's like a
+# multi-metric.
+#
+# Another (perhaps more important) facet of MM::Space is that it allows you to
+# specify a global scaling for each dimension. Given a constrained set of
+# possible morphologies, it's possible to have a "maximum metric distance" in a
+# single dimension of metric space, i.e., the distance between the two morphs
+# that are the furthest apart. MM::Space allows you to specify this for a given
+# space, thereby scaling all distances to the global maximum. A side-note is
+# that it's possible to specify one of these distances as an "edge" in one
+# dimension, allowing for directionality in Metric measurements.
+#
+# ## How do I generate new morphologies?
+#
+# MM::Space contains a library of search functions! So, the Space is treated as
+# a total search space, and the search functions search within that search space
+# (using depth-first, best-first, stochastic search, etc.) to try and find a
+# morphology that satisfies all your needs.
+#
+# ## How do I use MM::Space?
+#
+# Well I'm glad you asked. First, create some Metrics for the two dimensions:
+#
+x = MM::Metric.olm intra_delta: :tenney, inter_delta: :abs
+y = MM::Metric.olm intra_delta: :ratio, inter_delta: :abs
+#
+# Next, decide upon a central "start" morph for our search
+#
+start = %w(1/1 5/4 3/2 8/7 9/8).map {|x| MM::Ratio.from_s(x)}
+#
+# Initialize a Space with two dimensions <x, y>
+# 
+space = Space.new [x, y]
+# 
+# Now let's impose some global scaling limits on either dimension of the space.
+#
+space.max_distance = [8.414, 3.0]
+#
+# Now, let's try and find a morph 0.4 away in both directions at the same time
+#
+space.morph start, to: [0.4, 0.4] # => Returns a morph 
+#
+# Let's add some notion of "up" and "down" to our space. Let the "down" be the
+# vector of the same length as start, but all unison ratios.
+#
+space.lowest = start.map {|x| MM::Ratio.from_s("1/1")}
+# 
+# Now we can morph using distances that are signed in our global space!
+# Basically, this means "find a morph 0.4 away, where the new morph is closer to
+# the lowest point than the starting morph."
+#
+space.morph start, to: [-0.4, 0.4] # => Returns a morph
+#
+# Generate a bunch of distances
+#
+distances = [[0.1, -0.1], [0.2, -0.2], [0.3, -0.3]]
+#
+# Pass the Enumerator to the object. This keeps state and various other
+# information for each iteration, making it faster for successive lookups. 
+# 
+space.morph start, to: distances.each
+#
+# Parallel threads!
+#
+space.morph start, to: distances.each, threads: 4
+#
+# Of course this wouldn't be Ruby if we didn't use a block!
+#
+space.enter do |s|
+  morph start, to: distances.each
+  morph start, to: distances.each, threads: 4
+  # Change some parameter of the space
+  s.lowest = start.map {|x| MM::Ratio.from_s("8/1")}
+  # Etc. etc...
+end
+

data/lib/mm/space.rb

@@ -0,0 +1,167 @@
+module MM; end
+
+class MM::Space
+  VERSION = "1.0.0"
+
+  attr_accessor :delta, :search_klass
+  attr_reader :max_distance, :metric, :boundaries
+  attr_writer :adjacent_points_function, :cost_function
+
+  # Initialization method for MM::Space
+  #
+  # metric - Array of MM::Metrics, where each metric corresponds to a dimension
+  #   in the MM::Space.
+  # opts - Hash with additional parameters. (default: {})
+  #   :delta - The delta of the MM::Search function used in #morph.
+  #     (default: 0.001)
+  #   :boundaries - Array of same size as metric containing pairs [low,
+  #     high], which should be the bounding vectors of a given MM::Space.
+  #   :adjacent_points_function - Proc to use as the
+  #     adjacent_points_function for MM::Search in #morph.
+  #   :cost_function - Proc to use for cost_function for MM::Search in
+  #     #morph.
+  #   
+  # Returns an MM::Space object
+  def initialize metric, opts = {}
+    @metric = metric
+    @search_klass = opts[:search_klass] || MM::Search
+    @delta = opts[:delta] || 0.001
+    @boundaries = opts[:boundaries]
+    @adjacent_points_function = opts[:adjacent_points_function]
+    @cost_function = opts[:cost_function]
+  end
+
+  # Morphs to a given point within the space
+  #
+  # start_morph - Enumerable object of things to morph from
+  # to - Array to morph to, with one element for each dimension
+  #
+  # Returns Array of resulting MM::Ratio objects
+  def morph start_morph, to: nil, current_point: nil
+    if current_point
+      # puts "Finding from #{current_point.map {|r| r.join ' '}}"
+      searcher(start_morph, to).find_from_point current_point
+    else
+      searcher(start_morph, to).find
+    end
+  end
+
+  def max_distance= d
+    if d.respond_to? :each
+      # Assign global maxes to each dimension
+      d.zip(@metric).each do |distance_and_metric|
+        distance_and_metric[1].scale = MM::Scaling.get_global(distance_and_metric[0])
+      end
+
+      @max_distance = d
+    elsif d.is_a? Numeric
+      # Wrap it in an Array so it can be zipped
+      self.max_distance = [d]
+    else
+      raise ArgumentError, "arg to max_distance= must respond_to? #zip or be Numeric"
+    end
+  end
+
+  def metric= m
+    if m.respond_to? :each
+      @metric = m
+    elsif m.respond_to? :call
+      # Wrap it in an Array so it can be zipped
+      self.metric = [m]
+    else
+      raise ArgumentError, "arg to metric= must respond_to? #each or #call"
+    end
+  end
+
+  # Default cost_function to use if no other one is specified. Takes the root of
+  # the sum of the squares, or the generalized Euclidean distance.
+  #
+  # start_morph - morph to begin the morph from. This should be a valid morph in
+  #   the space (i.e., not out of bounds), and should also work with MM::Metric.
+  # to - Destination vector. There should be one dimension in the Array for each
+  #   element in @metric
+  #
+  # Returns a Proc that calculates how much the current difference vector
+  # differs from the requested difference vector.
+  def cost_function start_morph, to
+    @cost_function ||
+    ->(current_point) {
+      @metric.zip(to).inject(0) {|memo, x|
+        distance = x[0].call(start_morph, current_point)
+        unless @boundaries.nil?
+          start_to_lowest = x[0].call(start_morph, @boundaries[0][0])
+          current_to_lowest = x[0].call(current_point, @boundaries[0][0])
+          if start_to_lowest > current_to_lowest
+            distance = distance * -1.0
+          end
+        end
+        memo = memo + (distance - x[1]).abs ** 2
+      } ** 0.5
+    }
+  end
+
+  # Default adjacent_points_function. It takes all repeated permutations of a
+  # given morph.
+  #
+  # Returns the adjacent_points_function Proc.
+  def adjacent_points_function
+    @adjacent_points_function ||
+    ->(current_point) {
+      current_point.repeated_permutation(current_point.size)
+    }
+  end
+
+  def boundaries= boundaries
+    @boundaries = boundaries
+    self.max_distance = boundaries.zip(@metric).map {|boundary_metric|
+      boundary_metric[1].call(*boundary_metric[0])
+    }
+  end
+  
+  # Allows for morphing within a given block. 
+  #
+  # locals - Hash of key-value pairs where the key is the name of the local
+  #   variable to be created and the value is the value of that variable. Note
+  #   that it actually creates *methods*, rather than *variables*, and that these
+  #   methods refer to instance variables that are then removed. It could get
+  #   buggy if you were to try to create a variable that was the same name as an
+  #   existing method or class variable. (default: {})
+  # block - Block to evaluate within the context of the instance.
+  #
+  # Returns the last element returned by the block.
+  def enter locals = {}, &block
+    create_local_variables locals
+    output = instance_eval &block
+    remove_local_variables locals
+    output
+  end
+
+  protected 
+
+  def searcher start_morph, to
+    search = @search_klass.new(start_morph)
+    search.cost_function = cost_function start_morph, to
+    search.adjacent_points_function = adjacent_points_function
+    search.delta = @delta
+    search
+  end
+
+  private 
+
+  def create_local_variables locals
+    locals.each do |name, value|
+      define_singleton_method name do 
+        value
+      end
+    end
+  end
+
+  def remove_local_variables locals
+    locals.each do |name, value|
+      self.singleton_class.class_eval do
+        remove_method name
+      end
+    end
+  end
+end
+

data/test/mm/test_space.rb

@@ -0,0 +1,161 @@
+require "minitest/autorun"
+require "mm/space"
+require "mm"
+
+class TestMM < Minitest::Test; end
+
+class TestMM::TestSpace < Minitest::Test
+  def setup
+    @x = MM::Metric.olm intra_delta: :tenney, inter_delta: :abs
+    @y = MM::Metric.olm intra_delta: :log_ratio, inter_delta: :abs
+    @space = MM::Space.new [@x, @y], delta: 0.5
+  end
+
+  # Testing the attribute methods
+  def test_max_distance_multi_dimensional
+    @space.max_distance = [8.414, 3.0]
+    assert_equal [8.414, 3.0], @space.max_distance
+  end
+  
+  def test_max_distance_single_dimensional_sets_properly
+    @space.max_distance = 8.414
+    assert_equal [8.414], @space.max_distance
+  end
+
+  def test_set_and_get_metric_multi_dimensional
+    @space.metric = [@y, @x]
+    assert_equal MM::Deltas.singleton_method(:tenney),
+      @space.metric[1].instance_variable_get(:@intra_delta)
+  end
+
+  def test_metric_single_dimensional_sets_properly
+    @space.metric = @y
+    assert_equal MM::Deltas.singleton_method(:log_ratio), 
+      @space.metric[0].instance_variable_get(:@intra_delta)
+  end
+
+  def test_metric_boundaries_sets_max_distance
+    metric = MM::Metric.olm intra_delta: :abs, inter_delta: :abs
+    @space.metric = [metric]
+    @space.boundaries = [[[0.0, 0.0], [0.0, 1.0]]]
+    assert_equal [1.0], @space.max_distance
+  end
+
+  # Testing that the cost function is the root of sum of squares
+  def test_cost_function
+    cost = @space.cost_function(start_morph, [0.4, 0.4])
+    assert_in_delta 0.5657, cost.call(start_morph)
+  end
+
+  # Testing the morphing methods
+  def test_morph_to_not_nil
+    refute_nil new_morph
+  end
+
+  def test_morph_same_length
+    assert_equal start_morph.length, new_morph.length
+  end
+
+  def test_morph_proper_distance_away
+    @space.max_distance = [4.907, 0.263]
+    @space.delta = 0.15
+    res = @space.morph start_morph, to: [0.4, 0.4]
+    assert_in_delta 0.5657, root_of_sum_of_squares([@x, @y], start_morph, res), 0.15
+  end
+
+  def test_morph_works_with_single_dimensions
+    @space.metric = @x
+    @space.max_distance = [4.907]
+    @space.delta = 0.25
+    @new_morph = @space.morph start_morph, to: [0.4]
+    x_distance = @x.call(start_morph, new_morph)
+    assert_in_delta 0.4, x_distance, 0.25
+  end
+
+  # TODO: Perhaps redesign this so that you would pass a "direction" vector as
+  # well? 0 could be "closer to lowest" and 1 could be "closer to highest".
+  def test_morph_gets_negative_distances
+    metric = MM::Metric.olm intra_delta: :abs, inter_delta: :abs
+    @space = MM::Space.new [metric], delta: 0.001
+    @space.boundaries = [[[0.0, 0.0], [0.0, 1.0]]]
+    @space.adjacent_points_function = one_tenth_adjacent_point
+    start_morph = [0.0, 0.5]
+
+    res = @space.morph start_morph, to: [-0.1]
+    lowest = @space.boundaries[0][0]
+
+    refute_nil res
+    assert metric.call(lowest, start_morph) > metric.call(lowest, res)
+    assert_in_delta 0.1, metric.call(start_morph, res), 0.001
+  end
+
+  # Testing that the whole block situation works
+  def test_morph_enter_finds_in_block
+    @space.max_distance = [4.907, 0.263]
+    @space.delta = 0.15
+    res = @space.enter :start => start_morph do 
+      morph start, to: [0.4, 0.4] 
+    end
+    assert_in_delta 0.5657, root_of_sum_of_squares([@x, @y], start_morph, res), 0.15
+  end
+
+  def test_morph_enter_passes_self_to_block
+    res = @space.enter :start => start_morph do |s|
+      s.max_distance = [4.907, 0.263]
+      s.delta = 0.15
+      morph start, to: [0.4, 0.4] 
+    end
+    assert_in_delta 0.5657, root_of_sum_of_squares([@x, @y], start_morph, res), 0.15
+  end
+  
+  def test_morph_enter_receives_local_variables
+    res = @space.enter :start => start_morph do
+      start
+    end
+    assert_equal start_morph, res
+  end
+
+  def test_morph_enter_cleans_up_local_variables
+    @space.enter :start => start_morph do
+      start
+    end
+    refute_respond_to @space, :start
+  end
+
+  # Some helper buddies
+  def start_morph
+    @start_morph ||= %w(1/1 5/4 3/2).map {|x| MM::Ratio.from_s(x)}
+  end
+
+  def start_morph= start_morph
+    @start_morph = start_morph
+  end
+
+  def new_morph
+    @new_morph ||= @space.morph start_morph, to: [0.4, 0.4]
+  end
+
+  def call_metrics metrics, start, result
+    metrics.map do |m|
+      m.call(start, result)
+    end
+  end
+
+  def root_of_sum_of_squares metrics, v1, v2
+    (call_metrics metrics, v1, v2).inject(0) {|m, d| m = m + d**2} ** 0.5
+  end
+
+  def one_tenth_adjacent_point
+    ->(current_point) {
+      [-0.1, 0.0, 0.1].repeated_permutation(current_point.size).map {|v|
+        vz = v.zip(current_point).map {|vp|
+          vp = vp.inject(0.0, :+)
+        }
+        vz.any? {|p| p < 0.0 || p > 1.0 } ? nil : vz
+      }.compact
+    }
+  end
+
+  attr_writer :new_morph
+end
+

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: morphological_metrics-space
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Andrew Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.16'
+description: |-
+  MM::Space is a framework for working with Morphological Metrics and
+  Morphological Mutations in Ruby. A core component of MM::Space is that it has a
+  notion of global distance throughout a series of measurements or
+  transformations. This is what "Space" implies. It uses coworker libraries
+  MM::Metric and MM::Mutation to drive these measurements and transformations.
+email:
+- andrewchristophersmith@gmail.com
+executables:
+- mm_space
+extensions: []
+extra_rdoc_files:
+- History.txt
+- Manifest.txt
+- README.rdoc
+files:
+- ".autotest"
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- bin/mm_space
+- lib/mm/space.rb
+- test/mm/test_space.rb
+homepage: https://github.com/andrewcsmith/mm-space
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.4'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: MM::Space is a framework for working with Morphological Metrics and Morphological
+  Mutations in Ruby
+test_files: []