interpolate 0.2.4 → 0.3.0

data/lib/interpolate/version.rb

@@ -0,0 +1,6 @@
+module Interpolate
+  VERSION_MAJOR = 0
+  VERSION_MINOR = 3
+  VERSION_BUILD = 0
+  VERSION = [VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD].join('.')
+end

data/test/test_all.rb

@@ -1,14 +1,17 @@
 #!/usr/bin/env ruby
 
+$LOAD_PATH.unshift File.expand_path('../lib')
+
 require 'test/unit'
 require 'interpolate'
 
 
 class InterpolationTest < Test::Unit::TestCase
   # acceptable delta; floating point values won't be exact
-  DELTA = 1e-7
+  DELTA = (1.0 - (1.2 - 0.1 - 0.1)) * 100.0
 
   def setup
+    # NOTE changing these stock points will alter later tests!
     decimal_points = {
       0 => 0,
       1 => 0.1,
@@ -29,56 +32,91 @@ class InterpolationTest < Test::Unit::TestCase
       500 => [10, 100, 1000]
     }.freeze
 
-    @dec_gradient = Interpolation.new(decimal_points).freeze
-    @array_gradient = Interpolation.new(array_points).freeze
+    @dec_gradient = Interpolate::Points.new(decimal_points).freeze
+    @array_gradient = Interpolate::Points.new(array_points).freeze
+
+    @floor_func = Proc.new{|low, high, bal| low }
+    @ceil_func  = Proc.new{|low, high, bal| high }
+  end
+
+
+  def test_point_counts
+    assert_equal(11, @dec_gradient.points.size)
+    assert_equal(3, @array_gradient.points.size)
   end
 
 
-  def test_bad_points
+  def test_overlapping_points
+    gradient = @dec_gradient.dup
+
+    # one point added, non-overlapping
+    gradient.merge!(11 => 1.1)
+    assert_equal(12, gradient.points.size)
+
+    # one point added, overlapping
+    gradient.merge!(8 => 1.2)
+    assert_equal(12, gradient.points.size)
+
+    # verify overlapping point change
+    assert_in_delta(1.2, gradient.at(8), DELTA)
+  end
+
+
+  def test_bad_point
     bad_points = {
-      0 => 4.2,
-      1 => "hello", # not allowed by default
-      2 => 3.4,
-      3 => 4.8
+      0   => 0,
+      'h' => 3,  # non-Numeric key point not allowed
+      2   => 5,
+      3   => 10
     }
 
     assert_raise ArgumentError do
-      gradient = Interpolation.new(bad_points)
+      gradient = Interpolate::Points.new(bad_points)
     end
 
+    assert_raise ArgumentError do
+      gradient = Interpolate::Points.new
+      gradient.merge(bad_points)
+    end
   end
 
+
   def test_lower_bounds
-    assert_equal(@dec_gradient.at(0), 0)
-    assert_equal(@dec_gradient.at(-1), 0)
-    assert_equal(@dec_gradient.at(-10), 0)
-    assert_equal(@dec_gradient.at(-100), 0)
+    assert_equal(0, @dec_gradient.at(0))
+    assert_equal(0, @dec_gradient.at(-1))
+    assert_equal(0, @dec_gradient.at(-10))
+    assert_equal(0, @dec_gradient.at(-100))
   end
 
+
   def test_upper_bounds
-    assert_equal(@dec_gradient.at(10), 1)
-    assert_equal(@dec_gradient.at(100), 1)
-    assert_equal(@dec_gradient.at(1000), 1)
+    assert_equal(1, @dec_gradient.at(10))
+    assert_equal(1, @dec_gradient.at(50))
+    assert_equal(1, @dec_gradient.at(100))
+    assert_equal(1, @dec_gradient.at(500))
   end
 
+
   def test_midpoints
-    assert_in_delta(@dec_gradient.at(1.5), 0.15, DELTA)
-    assert_in_delta(@dec_gradient.at(2.5), 0.25, DELTA)
-    assert_in_delta(@dec_gradient.at(3.5), 0.35, DELTA)
-    assert_in_delta(@dec_gradient.at(4.5), 0.45, DELTA)
-    assert_in_delta(@dec_gradient.at(5.5), 0.55, DELTA)
-    assert_in_delta(@dec_gradient.at(6.5), 0.65, DELTA)
-    assert_in_delta(@dec_gradient.at(7.5), 0.75, DELTA)
-    assert_in_delta(@dec_gradient.at(8.5), 0.85, DELTA)
-    assert_in_delta(@dec_gradient.at(9.5), 0.95, DELTA)
+    1.5.step(9.5, 1.0) do |point|
+      assert_in_delta(point / 10.0, @dec_gradient.at(point), DELTA)
+    end
   end
 
+
   def test_precision
-    assert_in_delta(@dec_gradient.at(1.5555), 0.15555, DELTA)
-    assert_in_delta(@dec_gradient.at(2.5678), 0.25678, DELTA)
-    assert_in_delta(@dec_gradient.at(3.5701), 0.35701, DELTA)
+    [
+      0.12343232,
+      0.35583519,
+      0.54363462,
+      0.67658245,
+      0.89234124
+    ].each do |point|
+      assert_in_delta(point / 10.0, @dec_gradient.at(point), DELTA)
+    end
   end
 
+
   def test_gradient_merge
     new_points = {
       11 => 1.1,
@@ -93,16 +131,17 @@ class InterpolationTest < Test::Unit::TestCase
       20 => 2
     }
 
-    original = @dec_gradient.dup
-    expanded = original.merge(new_points)
+    base = @dec_gradient.dup
+    expanded = base.merge(new_points)
 
-    assert_equal(original.at(5), 0.5)
-    assert_equal(expanded.at(5), 0.5)
+    assert_equal(0.5, base.at(5))
+    assert_equal(0.5, expanded.at(5))
 
-    assert_equal(original.at(15), 1)
-    assert_equal(expanded.at(15), 1.5)
+    assert_equal(1.0, base.at(15))
+    assert_equal(1.5, expanded.at(15))
   end
 
+
   def test_gradient_merge!
     new_points = {
       11 => 1.1,
@@ -117,23 +156,26 @@ class InterpolationTest < Test::Unit::TestCase
       20 => 2
     }
 
-    original = @dec_gradient.dup
-    expanded = original.dup
-    expanded.merge!(new_points)
+    base = @dec_gradient.dup
+    expanded = base.merge(new_points)
 
-    assert_equal(original.at(5), 0.5)
-    assert_equal(expanded.at(5), 0.5)
+    # should match (original range)
+    assert_equal(0.5, base.at(5))
+    assert_equal(0.5, expanded.at(5))
 
-    assert_equal(original.at(15), 1)
-    assert_equal(expanded.at(15), 1.5)
+    # should be different (expanded range)
+    assert_equal(1.0, base.at(15))
+    assert_equal(1.5, expanded.at(15))
   end
 
+
   def test_array_values
-    assert_equal(@array_gradient.at(150), [3, 30, 300])
-    assert_equal(@array_gradient.at(200), [5, 50, 500])
-    assert_equal(@array_gradient.at(350), [7.5, 75, 750])
+    assert_equal([3, 30, 300], @array_gradient.at(150))
+    assert_equal([5, 50, 500], @array_gradient.at(200))
+    assert_equal([7.5, 75, 750], @array_gradient.at(350))
   end
 
+
   def test_frozen_points
     a = @array_gradient.at(200)
     assert_nothing_raised RuntimeError do
@@ -143,5 +185,37 @@ class InterpolationTest < Test::Unit::TestCase
     end
   end
 
+
+  def test_stored_blend_function
+    gradient = @dec_gradient.dup
+
+    # floor function
+    gradient.blend_with(&@floor_func)
+    0.5.step(9.5, 1.0) do |point|
+      assert_in_delta((point - 0.5) / 10.0, gradient.at(point), DELTA)
+    end
+
+    # ceiling
+    gradient.blend_with(&@ceil_func)
+    0.5.step(9.5, 1.0) do |point|
+      assert_in_delta((point + 0.5) / 10.0, gradient.at(point), DELTA)
+    end
+  end
+
+
+  def test_given_blend_function
+    gradient = @dec_gradient.dup
+
+    # floor
+    0.5.step(9.5, 1.0) do |point|
+      assert_in_delta((point - 0.5) / 10.0, gradient.at(point, &@floor_func), DELTA)
+    end
+
+    # ceiling
+    0.5.step(9.5, 1.0) do |point|
+      assert_in_delta((point + 0.5) / 10.0, gradient.at(point, &@ceil_func), DELTA)
+    end
+  end
+
 end
 

metadata

@@ -1,45 +1,33 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: interpolate
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 4
-  version: 0.2.4
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Adam Collins
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-10 00:00:00 -07:00
-default_executable: 
+date: 2012-09-05 00:00:00.000000000 Z
 dependencies: []
-
-description: |
-  Description
-  
-  Library for generic Interpolation objects. Useful for such things as generating
-  linear motion between points (or arrays of points), multi-channel color
-  gradients, piecewise functions, or even just placing values within intervals.
-
-email: adam@m104.us
+description: Interpolate is a library for generic linear interpolation objects. Useful
+  for such things as calculating linear motion between locations (or arrays of locations),
+  multi-channel color gradients, piecewise functions, or even just placing values
+  within intervals.
+email:
+- adam@m104.us
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- LICENSE
-- README.md
-files: 
+extra_rdoc_files: []
+files:
+- .gitignore
 - CHANGELOG.md
+- Gemfile
 - LICENSE
-- Manifest.txt
 - README.md
 - Rakefile
-- VERSION
+- TODO
 - examples/arrays.rb
 - examples/buckets.rb
 - examples/colors.rb
@@ -49,43 +37,32 @@ files:
 - lib/interpolate/add/core.rb
 - lib/interpolate/add/core/array.rb
 - lib/interpolate/add/core/numeric.rb
-- lib/interpolate/interpolation.rb
+- lib/interpolate/base.rb
+- lib/interpolate/version.rb
 - test/test_all.rb
-has_rdoc: true
 homepage: http://github.com/m104/interpolate
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Create linear interpolations from key points and values
-test_files: 
-- examples/arrays.rb
-- examples/buckets.rb
-- examples/colors.rb
-- examples/nested.rb
+summary: Create arbitrary interpolations from key points and values
+test_files:
 - test/test_all.rb

data/Manifest.txt

@@ -1,16 +0,0 @@
-CHANGELOG.md
-LICENSE
-Manifest.txt
-Rakefile
-README.md
-VERSION
-examples/arrays.rb
-examples/buckets.rb
-examples/colors.rb
-examples/nested.rb
-lib/interpolate.rb
-lib/interpolate/interpolation.rb
-lib/interpolate/add/core.rb
-lib/interpolate/add/core/array.rb
-lib/interpolate/add/core/numeric.rb
-test/test_all.rb

data/VERSION

@@ -1 +0,0 @@
-0.2.4

data/lib/interpolate/interpolation.rb

@@ -1,117 +0,0 @@
-# Library for generic interpolation objects. Useful for such things as generating
-# linear motion between points (or arrays of points), multi-channel color
-# gradients, piecewise functions, or even just placing values within intervals.
-#
-# The only requirement is that each interpolation point value must be able to
-# figure out how to interpolate itself to its neighbor value(s). Numeric
-# objects and uniformly sized arrays are automatically endowed with this
-# ability by this gem, but other classes will require an implementation
-# of +interpolate+. See the example color.rb in the examples directory for
-# a brief demonstration using Color objects provided by the 'color' gem.
-#
-# Interpolation objects are constructed with a Hash object, wherein each key
-# is a real number value and each value is can respond to +interpolate+ and
-# determine the resulting value based on its neighbor value and the balance
-# ratio between the two points.
-#
-# At or below the lower bounds of the interpolation, the result will be equal to
-# the value of the lower bounds interpolation point.  At or above the upper
-# bounds of the graient, the result will be equal to the value of the upper
-# bounds interpolation point.
-#
-#
-# ==Author
-#
-# {Adam Collins}[mailto:adam@m104.us]
-#
-#
-# ==License
-#
-# Licensed under the MIT license.
-#
-
-class Interpolation
-  VERSION = '0.2.4'
-
-  # creates an Interpolation object with Hash object that specifies
-  # each point location (Numeric) and value (up to you)
-  def initialize(points = {})
-    @points = {}
-    merge!(points)
-  end
-
-  # creates an Interpolation object from the receiver object,
-  # merged with the interpolated points you specify
-  def merge(points = {})
-    Interpolation.new(points.merge(@points))
-  end
-
-  # merges the interpolation points with the receiver object
-  def merge!(points = {})
-    @points.merge!(points)
-    normalize_data
-  end
-
-  # returns the interpolated value of the receiver object at the point specified
-  def at(point)
-    # deal with the two out-of-bounds cases first
-    if (point <= @min_point)
-      return @data.first.last
-    elsif (point >= @max_point)
-      return @data.last.last
-    end
-
-    # go through the interpolation intervals, in order, to determine
-    # into which this point falls
-    1.upto(@data.length - 1) do |interval|
-      left = @data.at(interval - 1)
-      right = @data.at(interval)
-      interval_range = left.first..right.first
-
-      if (interval_range.include?(point))
-        # what are the points in question?
-        left_point = left.first.to_f
-        right_point = right.first.to_f
-
-        # what are the values in question?
-        left_value = left.last
-        right_value = right.last
-
-        # span: difference between the left point and right point
-        # balance: ratio of right point to left point
-        span = right_point - left_point
-        balance = (point.to_f - left_point) / span
-
-        # catch the cases where the point in quesion is
-        # on one of the interval's endpoints
-        return left_value if (balance == 0.0)
-        return right_value if (balance == 1.0)
-
-        # otherwise, we need to interpolate
-        return left_value.interpolate(right_value, balance)
-      end
-    end
-
-    # we shouldn't get to this point
-    raise "couldn't come up with a value for some reason!"
-  end
-
-  private
-
-  def normalize_data # :nodoc:
-    @data = @points.sort
-    @min_point = @data.first.first
-    @max_point = @data.last.first
-
-    # make sure that all values respond_to? :interpolate
-    @data.each do |point|
-      value = point.last
-      unless value.respond_to?(:interpolate)
-        raise ArgumentError, "found an interpolation point that doesn't respond to :interpolate"
-      end
-    end
-  end
-
-end
-
-