interpolate 0.2.1 → 0.2.2

data/{CHANGELOG.txt → History.txt}

@@ -1,3 +1,9 @@
+== 0.2.2 (2008.2.4)
+
+* Single source file has been split into Class files
+* Tests now use +freeze
+* Better edge case testing in the Array and Numeric +interpolate+ methods
+
 == 0.2.1 (2008.1.27)
 
 * First public release

data/Manifest.txt

@@ -1,4 +1,4 @@
-CHANGELOG.txt
+History.txt
 LICENSE.txt
 Manifest.txt
 README.txt
@@ -8,4 +8,7 @@ examples/colors.rb
 examples/nested.rb
 examples/zones.rb
 lib/interpolate.rb
+lib/interpolate/interpolation.rb
+lib/interpolate/ruby_array.rb
+lib/interpolate/ruby_numeric.rb
 test/test_all.rb

data/Rakefile

@@ -10,7 +10,7 @@ Hoe.new('Interpolate', Interpolation::VERSION) do |p|
   p.url = "http://interpolate.rubyforge.org"
   p.description = File.read('README.txt').delete("\r").split(/^== /)[2].chomp.chomp
   p.summary = p.description
-  p.changes = File.read('CHANGELOG.txt').delete("\r").split(/^== /)[1].chomp
+  p.changes = File.read('History.txt').delete("\r").split(/^== /)[1].chomp
   p.remote_rdoc_dir = '' # Release to root
 end
 

data/lib/interpolate.rb

@@ -1,156 +1,3 @@
-# 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.w.collins@gmail.com]
-#
-#
-# ==License
-#
-# Licensed under the MIT license.
-#
-
-class Interpolation
-  VERSION = '0.2.1' # :nodoc:
-
-  # 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 |zone|
-      left = @data.at(zone - 1)
-      right = @data.at(zone)
-      zone_range = left.first..right.first
-
-      if (zone_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 zone'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
-
-
-# all numeric objects should be supported
-class Numeric   # :nodoc:
-  def interpolate(other, balance)
-    left = self.to_f
-    right = other.to_f
-    delta = (right - left).to_f
-    return left + (delta * balance)
-  end
-end
-
-
-# a little more complicated, but there's no reason why we can't
-# interpolate between two equal length arrays as long as each element
-# responds to +interpolate+
-class Array   # :nodoc:
-  def interpolate(other, balance)
-    if (self.length < 1) then
-      raise ArgumentError, "cannot interpolate array with no values"
-    end
-
-    if (self.length != other.length) then
-      raise ArgumentError, "cannot interpolate between arrays of different length"
-    end
-
-    final = Array.new
-
-    self.each_with_index do |left, index|
-      unless (left.respond_to? :interpolate) then
-        raise "array element does not respond to :interpolate"
-      end
-
-      right = other[index]
-
-      final[index] = left.interpolate(right, balance)
-    end
-
-    return final
-  end
-end
+require 'interpolate/interpolation'
+require 'interpolate/ruby_array'
+require 'interpolate/ruby_numeric'

data/lib/interpolate/interpolation.rb

@@ -0,0 +1,116 @@
+# 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.w.collins@gmail.com]
+#
+#
+# ==License
+#
+# Licensed under the MIT license.
+#
+
+class Interpolation
+  VERSION = '0.2.2'
+
+  # 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 |zone|
+      left = @data.at(zone - 1)
+      right = @data.at(zone)
+      zone_range = left.first..right.first
+
+      if (zone_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 zone'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
+

data/lib/interpolate/ruby_array.rb

@@ -0,0 +1,59 @@
+# Extension(s) for the Ruby Array class.
+#
+#
+# ==Author
+#
+# {Adam Collins}[mailto:adam.w.collins@gmail.com]
+#
+#
+# ==License
+#
+# Licensed under the MIT license.
+#
+
+class Array
+  # Returns a new Array in which each element is the interpolated value
+  # between +self+ and +other+.  +balance+ should be a Float from 0.0
+  # to 1.0 where the value is a ratio between +self+ and +other+.  +self+
+  # and +other+ should be arrays of equal, non-zero length.
+  #
+  # Between two interpolation points, let's say +a+ and +b+, the final result
+  # will be +c+ where <tt>c[0]</tt> is the interpolation of <tt>a[0]</tt> and
+  # <tt>b[0]</tt> and <tt>c[1]</tt> is interpolated between <tt>a[1]</tt> and
+  # <tt>b[1]</tt> and so on, up to <tt>c[c.length - 1]</tt>.
+  #
+  # This method is intentionally abstract to allow for the interpolation
+  # of nested arrays.  In this case, both arrays need to have the same array
+  # structure (same number of dimensions, equal length in each dimension), 
+  # but the contents can, of course, be different.
+  #
+  # A balance greater than or equal to 0.0 returns +self+, while a
+  # balance less than or equal to 1.0 returns +other+.
+  def interpolate(other, balance)
+    if (self.length < 1) then
+      raise ArgumentError, "cannot interpolate array with no values"
+    end
+
+    if (self.length != other.length) then
+      raise ArgumentError, "cannot interpolate between arrays of different length"
+    end
+
+    # catch the easy cases
+    return self.dup if (balance <= 0.0)
+    return other.dup if (balance >= 1.0)
+
+    final = Array.new
+
+    self.each_with_index do |left, index|
+      unless (left.respond_to? :interpolate) then
+        raise "array element does not respond to :interpolate"
+      end
+
+      right = other[index]
+
+      final[index] = left.interpolate(right, balance)
+    end
+
+    return final
+  end
+end

data/lib/interpolate/ruby_numeric.rb

@@ -0,0 +1,34 @@
+# Extension(s) for the Ruby Numeric class.
+#
+#
+# ==Author
+#
+# {Adam Collins}[mailto:adam.w.collins@gmail.com]
+#
+#
+# ==License
+#
+# Licensed under the MIT license.
+#
+
+class Numeric
+  # Returns a Float that is equal to the interpolated value between
+  # +self+ and +other+.  +balance+ should be a Float from 0.0 to 1.0,
+  # where the value is a ratio between +self+ and +other+.
+  #
+  # A balance greater than or equal to 0.0 returns +self+, while a
+  # balance less than or equal to 1.0 returns +other+.
+  def interpolate(other, balance)
+    balance = balance.to_f
+    left = self.to_f
+    right = other.to_f
+    
+    # catch the easy cases
+    return left if (balance <= 0.0)
+    return right if (balance >= 1.0)
+    
+    delta = (right - left).to_f
+    return left + (delta * balance)
+  end
+end
+

data/test/test_all.rb

@@ -21,16 +21,16 @@ class InterpolationTest < Test::Unit::TestCase
       8 => 0.8,
       9 => 0.9,
       10 => 1
-    }
+    }.freeze
 
     array_points = {
       100 => [1,   10,  100],
       200 => [5,   50,  500],
       500 => [10, 100, 1000]
-    }
+    }.freeze
 
-    @dec_gradient = Interpolation.new(decimal_points)
-    @array_gradient = Interpolation.new(array_points)
+    @dec_gradient = Interpolation.new(decimal_points).freeze
+    @array_gradient = Interpolation.new(array_points).freeze
   end
 
 
@@ -133,6 +133,15 @@ class InterpolationTest < Test::Unit::TestCase
     assert_equal(@array_gradient.at(200), [5, 50, 500])
     assert_equal(@array_gradient.at(350), [7.5, 75, 750])
   end
+  
+  def test_frozen_points
+    a = @array_gradient.at(200)
+    assert_nothing_raised RuntimeError do
+      a[0] = 10
+      a[1] = 70
+      a[2] = 100
+    end
+  end
 
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: interpolate
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors: 
 - Adam Collins
@@ -30,7 +30,7 @@ cert_chain:
   xJc09X9KG2jBdxa4tp+uy7KZ
   -----END CERTIFICATE-----
 
-date: 2008-01-27 00:00:00 -08:00
+date: 2008-02-05 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,7 +40,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.4.0
+        version: 1.5.0
     version: 
 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.w.collins@gmail.com
@@ -49,12 +49,12 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- CHANGELOG.txt
+- History.txt
 - LICENSE.txt
 - Manifest.txt
 - README.txt
 files: 
-- CHANGELOG.txt
+- History.txt
 - LICENSE.txt
 - Manifest.txt
 - README.txt
@@ -64,6 +64,9 @@ files:
 - examples/nested.rb
 - examples/zones.rb
 - lib/interpolate.rb
+- lib/interpolate/interpolation.rb
+- lib/interpolate/ruby_array.rb
+- lib/interpolate/ruby_numeric.rb
 - test/test_all.rb
 has_rdoc: true
 homepage: http://interpolate.rubyforge.org