interpolate 0.2.3 → 0.2.4

data/{History.txt → CHANGELOG.md}

@@ -1,19 +1,18 @@
-== 0.2.3 (2009.10.27)
+== 0.2.4 (2011.4.10)
 
-* Support for passing a block to new Interpolation objects
+* Project cleanup: minor updates to the lib/ file structure and documentation
 
 == 0.2.2 (2008.2.4)
 
 * Single source file has been split into Class files
-* Tests now use +freeze
+* Tests now use +freeze+
 * Better edge case testing in the Array and Numeric +interpolate+ methods
 
 == 0.2.1 (2008.1.27)
 
-* First public release
-
-* Project Cleanup:
+First public release
 
+Project Cleanup:
   * Documentation enhancements and updates.
   * +add+ is now +merge+
 

data/{LICENSE.txt → LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2009 Adam Collins [adam.w.collins@gmail.com]
+Copyright (c) 2008-2011 Adam Collins [adam@m104.us]
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Manifest.txt

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

data/{README.txt → README.md}

@@ -1,39 +1,40 @@
-= Interpolate
+# Interpolate
 
-== Author
+## Author
 
-Adam Collins [adam.w.collins@gmail.com]
+Adam Collins [adam@m104.us]
 
 
-== 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.
 
 
-== General Usage
+## General Usage
 
 Specify the interpolation as a Hash, where keys represent numeric points
-along the gradient and values represent the known values along that gradient.
+along the gradient and values represent the known (key) values along that
+gradient.
 
-Here's an example for determining where, in a range of seven zones, each value
-of a set falls into:
+Here's an example for placing values within one of seven buckets:
 
   require 'rubygems'
   require 'interpolate'
 
-  points = {
-    0.000 => 0,
-    0.427 => 1,
-    1.200 => 2,
-    3.420 => 3,
-    27.50 => 4,
-    45.20 => 5,
-    124.4 => 6,
+  # min_value => bucket
+  buckets = {
+    0.000 => 1,
+    0.427 => 2,
+    1.200 => 3,
+    3.420 => 4,
+    27.50 => 5,
+    45.20 => 6,
+    124.4 => 7,
   }
 
-  zones = Interpolation.new(points)
+  bucketizer = Interpolation.new(buckets)
 
   values = [
     -20.2,
@@ -45,47 +46,51 @@ of a set falls into:
   ]
 
   values.each do |value|
-    zone = zones.at(value).floor
-    puts "A value of #{value} falls into zone #{zone}"
+    bucket = bucketizer.at(value).floor
+    puts "A value of #{value} falls into bucket #{bucket}"
   end
 
 
-== Non-Numeric Gradients
+## Non-Numeric Gradients
 
 For non-Numeric gradient value objects, you'll need to implement +interpolate+
-for the class in question or provide a block to the new Interpolation object.
-Here's an example using an RGB color gradient with the help of the 'color' gem:
+for the class in question.  Here's an example using an RGB color gradient with
+the help of the 'color' gem:
 
   require 'rubygems'
   require 'interpolate'
   require 'color'
 
+  # we need to implement +interpolate+ for Color::RGB
+  # in order for Interpolation to work
+  class Color::RGB
+    def interpolate(other, balance)
+      mix_with(other, balance * 100.0)
+    end
+  end
+
   # a nice weathermap-style color gradient
   points = {
-    0 => Color::RGB::White,
-    1 => Color::RGB::Lime,
-  # 2 => ? (something between Lime and Yellow)
-    3 => Color::RGB::Yellow,
-    4 => Color::RGB::Orange,
-    5 => Color::RGB::Red,
-    6 => Color::RGB::Magenta,
-    7 => Color::RGB::DarkGray
+    1 => Color::RGB::White,
+    2 => Color::RGB::Lime,
+  # 3 => ? (between Lime and Yellow; Interpolate will figure it out)
+    4 => Color::RGB::Yellow,
+    5 => Color::RGB::Orange,
+    6 => Color::RGB::Red,
+    7 => Color::RGB::Magenta
   }
 
-  gradient = Interpolation.new(points) do |left, right, balance|
-    left.mix_with(right, balance * 100.0)
-  end
+  gradient = Interpolation.new(points)
 
-  # what are the colors of the gradient from 0 to 7
+  # what are the colors of the gradient from 1 to 7
   # in increments of 0.2?
-  (0).step(7, 0.2) do |value|
+  (1).step(7, 0.2) do |value|
     color = gradient.at(value)
     puts "A value of #{value} means #{color.html}"
   end
 
 
-
-== Array-based Interpolations
+## Array-based Interpolations
 
 Aside from single value gradient points, you can interpolate over uniformly sized
 arrays.  Between two interpolation points, let's say +a+ and +b+, the final result
@@ -100,28 +105,28 @@ Here is an example:
   require 'pp'
 
   # a non-linear set of multi-dimensional points;
-  # perhaps the location of some actor in relation to time
+  # perhaps the location of an actor in relation to time
   time_frames = {
-    0 => [0, 0, 0],
-    1 => [1, 0, 0],
-    2 => [0, 1, 0],
-    3 => [0, 0, 2],
-    4 => [3, 0, 1],
-    5 => [1, 2, 3],
-    6 => [0, 0, 0]
+    1 => [0, 0, 0],
+    2 => [1, 0, 0],
+    3 => [0, 1, 0],
+    4 => [0, 0, 2],
+    5 => [3, 0, 1],
+    6 => [1, 2, 3],
+    7 => [0, 0, 0]
   }
 
   path = Interpolation.new(time_frames)
 
-  # play the actors positions in time increments of 0.25
-  (0).step(6, 0.25) do |time|
+  # play the actor's positions in time increments of 0.25
+  (1).step(7, 0.25) do |time|
     position = path.at(time)
     puts ">> At #{time}s, actor is at:"
     p position
   end
 
 
-== Nested Array Interpolations
+## Nested Array Interpolations
 
 As long as each top level array is uniformly sized in the first dimension
 and each nested array is uniformly sized in the second dimension (and so
@@ -134,8 +139,8 @@ Here's an example of a set of 2D points being morphed:
   require 'pp'
 
 
-  # a non-linear set of 2D vertexes;
-  # the shape changes at each frame
+  # a number of sets 2D vertices, each set corresponding to a particular
+  # shape on the grid
   time_frames = {
     0 => [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0]], # a horizontal line
     1 => [[0, 0], [1, 0], [3, 0], [0, 4], [0, 0]], # a triangle
@@ -155,11 +160,11 @@ Here's an example of a set of 2D points being morphed:
   end
 
 
-== License
+## License
 
 (The MIT License)
 
-Copyright (c) 2008-2009 Adam Collins [adam.w.collins@gmail.com]
+Copyright (c) 2008-2011 Adam Collins [adam@m104.us]
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,19 +1,35 @@
-require 'rubygems'
-require 'hoe'
-$:.unshift(File.dirname(__FILE__) + "/lib")
-require 'interpolate'
+require 'jeweler'
+require 'rake'
 
-Hoe.new('Interpolate', Interpolation::VERSION) do |p|
-  p.name = "interpolate"
-  p.author = "Adam Collins"
-  p.email = 'adam.w.collins@gmail.com'
-  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('History.txt').delete("\r").split(/^== /)[1].chomp
-  p.remote_rdoc_dir = '' # Release to root
+require './lib/interpolate/interpolation'
+
+Jeweler::Tasks.new do |g|
+  doc_sections = File.read('README.md').delete("\r").split(/^## /)
+
+  g.name = 'interpolate'
+  g.summary = 'Create linear interpolations from key points and values'
+  g.description = doc_sections[2].chomp.chomp # mmmm... tasty!
+  g.email = 'adam@m104.us'
+  g.homepage = "http://github.com/m104/interpolate"
+  g.authors = ["Adam Collins"]
+  g.version = Interpolation::VERSION
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList.new('test/test_*.rb') do |list|
+    list.exclude 'test/test_helper.rb'
+  end
+  test.libs << 'test'
+  test.verbose = true
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'interpolate'
+  rdoc.rdoc_files.include('README.markdown')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-desc "Release and publish documentation"
-task :repubdoc => [:release, :publish_docs]
 

data/VERSION

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

data/examples/arrays.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'interpolate'
 require 'pp'
 
+
 # a non-linear set of multi-dimensional points;
 # perhaps the location of some actor in relation to time
 time_frames = {

data/examples/buckets.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'interpolate'
+
+# min_value => bucket
+buckets = {
+  0.000 => 1,
+  0.427 => 2,
+  1.200 => 3,
+  3.420 => 4,
+  27.50 => 5,
+  45.20 => 6,
+  124.4 => 7,
+}
+
+bucketizer = Interpolation.new(buckets)
+
+values = [
+  -20.2,
+  0.234,
+  65.24,
+  9.234,
+  398.4,
+  4000
+]
+
+values.each do |value|
+  bucket = bucketizer.at(value).floor
+  puts "A value of #{value} falls into bucket #{bucket}"
+end
+
+
+

data/examples/colors.rb

@@ -1,30 +1,33 @@
 require 'rubygems'
-require 'interpolate'
 require 'color'
+require 'interpolate'
+
+# we need to implement +interpolate+ for Color::RGB
+# in order for Interpolation to work
+class Color::RGB
+  def interpolate(other, balance)
+    mix_with(other, balance * 100.0)
+  end
+end
 
 # a nice weathermap-style color gradient
 points = {
-  0 => Color::RGB::White,
-  1 => Color::RGB::Lime,
-# 2 => ? (something between Lime and Yellow)
-  3 => Color::RGB::Yellow,
-  4 => Color::RGB::Orange,
-  5 => Color::RGB::Red,
-  6 => Color::RGB::Magenta,
-  7 => Color::RGB::DarkGray
+  1 => Color::RGB::White,
+  2 => Color::RGB::Lime,
+# 3 => ? (between Lime and Yellow; Interpolate will figure it out)
+  4 => Color::RGB::Yellow,
+  5 => Color::RGB::Orange,
+  6 => Color::RGB::Red,
+  7 => Color::RGB::Magenta
 }
 
-# Color objects can't interpolate themselves right out of the box,
-# so rather than monkey patch the :interpolate method, you can pass
-# a block with the instantiation of a new Interpolation object
-gradient = Interpolation.new(points) do |left, right, balance|
-  left.mix_with(right, balance * 100.0)
-end
+gradient = Interpolation.new(points)
 
-# what are the colors of the gradient from 0 to 7
+# what are the colors of the gradient from 1 to 7
 # in increments of 0.2?
-(0).step(7, 0.2) do |value|
+(1).step(7, 0.2) do |value|
   color = gradient.at(value)
   puts "A value of #{value} means #{color.html}"
 end
 
+

data/examples/nested.rb

@@ -3,8 +3,8 @@ require 'interpolate'
 require 'pp'
 
 
-# a non-linear set of 2D vertexes;
-# the shape changes at each frame
+# a number of sets 2D vertices, each set corresponding to a particular
+# shape on the grid
 time_frames = {
   0 => [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0]], # a horizontal line
   1 => [[0, 0], [1, 0], [3, 0], [0, 4], [0, 0]], # a triangle

data/interpolate.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{interpolate}
+  s.version = "0.2.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Adam Collins"]
+  s.date = %q{2011-04-10}
+  s.description = %q{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.
+}
+  s.email = %q{adam@m104.us}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "CHANGELOG.md",
+    "LICENSE",
+    "Manifest.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "examples/arrays.rb",
+    "examples/buckets.rb",
+    "examples/colors.rb",
+    "examples/nested.rb",
+    "interpolate.gemspec",
+    "lib/interpolate.rb",
+    "lib/interpolate/add/core.rb",
+    "lib/interpolate/add/core/array.rb",
+    "lib/interpolate/add/core/numeric.rb",
+    "lib/interpolate/interpolation.rb",
+    "test/test_all.rb"
+  ]
+  s.homepage = %q{http://github.com/m104/interpolate}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Create linear interpolations from key points and values}
+  s.test_files = [
+    "examples/arrays.rb",
+    "examples/buckets.rb",
+    "examples/colors.rb",
+    "examples/nested.rb",
+    "test/test_all.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/interpolate.rb

@@ -1,3 +1,2 @@
+require 'interpolate/interpolation'
 require 'interpolate/add/core'
-require 'interpolate/add/array'
-require 'interpolate/add/numeric'

data/lib/interpolate/add/core.rb

@@ -1,123 +1,2 @@
-# 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.
-#
-# Interpolation objects are constructed with a Hash object, wherein each key
-# is a real number value and each value can respond to +interpolate+ to
-# determine the resulting value based on its neighbor value and the balance
-# ratio between the two points.
-#
-# For objects which can't respond to +interpolate+ (or to override the default
-# behaviour), a block can be passed to +new+ which will be called whenever two
-# values need to be interpolated.
-#
-# 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.3'
-
-  # creates an Interpolation object with Hash object that specifies
-  # each point location (Numeric) and value (up to you)
-  # 
-  # the optional+block+ can be used to interpolate objects that can't
-  # respond to +interpolate+ on their own
-  #
-  # +block+ will receive the following arguments: "left" (lower) side
-  # value, "right" (higher) side value, and the balance ratio from 0.0
-  # to 1.0
-  def initialize(points = {}, &block)
-    @points = {}
-    @block = block
-    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)
-
-        # given block should be called
-        return @block.call(left_value, right_value, balance) if @block
-
-        # otherwise, we need to interpolate
-        return left_value.interpolate(right_value, balance) if left_value.respond_to?(:interpolate)
-
-        raise ArgumentError, "no block given and interpolation point doesn't respond to :interpolate"
-      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
-    end
-  end
-
-end
-
+require 'interpolate/add/core/numeric'
+require 'interpolate/add/core/array'

data/lib/interpolate/interpolation.rb

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

data/test/test_all.rb

@@ -1,15 +1,15 @@
-#!/usr/bin/env ruby1.8 -w
+#!/usr/bin/env ruby
 
 require 'test/unit'
-require 'lib/interpolate'
+require 'interpolate'
 
 
 class InterpolationTest < Test::Unit::TestCase
-
+  # acceptable delta; floating point values won't be exact
   DELTA = 1e-7
 
   def setup
-    @decimal_points = {
+    decimal_points = {
       0 => 0,
       1 => 0.1,
       2 => 0.2,
@@ -23,28 +23,29 @@ class InterpolationTest < Test::Unit::TestCase
       10 => 1
     }.freeze
 
-    @array_points = {
+    array_points = {
       100 => [1,   10,  100],
       200 => [5,   50,  500],
       500 => [10, 100, 1000]
     }.freeze
 
-    @dec_gradient = Interpolation.new(@decimal_points).freeze
-    @array_gradient = Interpolation.new(@array_points).freeze
+    @dec_gradient = Interpolation.new(decimal_points).freeze
+    @array_gradient = Interpolation.new(array_points).freeze
   end
 
-  def test_bad_point
+
+  def test_bad_points
     bad_points = {
       0 => 4.2,
       1 => "hello", # not allowed by default
       2 => 3.4,
       3 => 4.8
     }
-    gradient = Interpolation.new(bad_points)
 
     assert_raise ArgumentError do
-      gradient.at(1.5)
+      gradient = Interpolation.new(bad_points)
     end
+
   end
 
   def test_lower_bounds
@@ -133,30 +134,6 @@ class InterpolationTest < Test::Unit::TestCase
     assert_equal(@array_gradient.at(350), [7.5, 75, 750])
   end
 
-  def test_given_block_left
-    gradient = Interpolation.new(@decimal_points) {|l, r, bal| l}
-    assert_in_delta(gradient.at(1.5), 0.1, DELTA)
-    assert_in_delta(gradient.at(2.5), 0.2, DELTA)
-    assert_in_delta(gradient.at(3.5), 0.3, DELTA)
-  end
-
-  def test_given_block_right
-    gradient = Interpolation.new(@decimal_points) {|l, r, bal| r}
-    assert_in_delta(gradient.at(1.5), 0.2, DELTA)
-    assert_in_delta(gradient.at(2.5), 0.3, DELTA)
-    assert_in_delta(gradient.at(3.5), 0.4, DELTA)
-  end
-
-  def test_given_block_mean_squared
-    # squared balance, not linear
-    gradient = Interpolation.new(@decimal_points) do |l, r, bal|
-      l + ((r - l).to_f * bal * bal)
-    end
-    assert_in_delta(gradient.at(1.5),  0.12500, DELTA)
-    assert_in_delta(gradient.at(2.75), 0.25625, DELTA)
-    assert_in_delta(gradient.at(3.99), 0.39801, DELTA)
-  end
-
   def test_frozen_points
     a = @array_gradient.at(200)
     assert_nothing_raised RuntimeError do

metadata

@@ -1,48 +1,23 @@
 --- !ruby/object:Gem::Specification 
 name: interpolate
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 4
+  version: 0.2.4
 platform: ruby
 authors: 
 - Adam Collins
 autorequire: 
 bindir: bin
-cert_chain: 
-- |
-  -----BEGIN CERTIFICATE-----
-  MIIDPjCCAiagAwIBAgIBADANBgkqhkiG9w0BAQUFADBFMRcwFQYDVQQDDA5hZGFt
-  LncuY29sbGluczEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQB
-  GRYDY29tMB4XDTA4MDEyNDA4NTEyOFoXDTA5MDEyMzA4NTEyOFowRTEXMBUGA1UE
-  AwwOYWRhbS53LmNvbGxpbnMxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmS
-  JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMP8
-  3Nz8g1K+Z4p59/keyov5ihFgzJuhlnvbRLr0y2jtDybeyc0TSMnY7sjhx+T0yVI5
-  9tEtUMo3d2m0woaHw7kc3VAo68GQKGAN02bdaPc4ODcObL9DAr8Y3CCwml5CiLtX
-  L5Lz8zO9EU6jv6bTecRW5DsY9nPjc/TLqXjYxDgSL8dppBmHs2k82bJCaCaTFj9M
-  ORRZpdkdTBdecI7p8DKt2WAX12deT/XUan7mpiBChKJsNVpcAe6CUqVfb6hMGA95
-  KtW+GxvK6F6UgkcFG8ljrXks8Dfm4jMYVkpmw1YUGYU9Wj9R8X94ecAi9By/ngJ7
-  svhO6ouvVk9J9hgpWukCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
-  HQYDVR0OBBYEFIpBCufIdqpuVqh/Mt46Gq9FKa0pMA0GCSqGSIb3DQEBBQUAA4IB
-  AQBbwpirH1tNzkESxQIBZd10xK3Dca141G9+lHl7OK3UCk1ZF6TiXxgl7Qnug4A5
-  3mEn/catvIdMYcA1GLNWL7qlW2Fpk2w0qgVbx1agK724BrZm5Op6lain+vi6BXd3
-  QM32MqZAL96e40i6UCutsNIdZeRDfR7hRcmqPTkoSUEu/3X6qegnvJHpVw36dsG6
-  trlR7ps6/GSlnZNkD5TayaybO3TiA+KGA19/zQhO6DMPds+swW0Jz7xv2VBzIWg5
-  RAnseWJ5nOAftsE9D1NGp3TEH+ceNKO3IP0OtDl9L2F0a/9XbPJdmsaQR+FPX30Z
-  xJc09X9KG2jBdxa4tp+uy7KZ
-  -----END CERTIFICATE-----
+cert_chain: []
 
-date: 2009-10-27 00:00:00 -07:00
+date: 2011-04-10 00:00:00 -07:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.3.3
-    version: 
+dependencies: []
+
 description: |
   Description
   
@@ -50,59 +25,67 @@ description: |
   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
+email: adam@m104.us
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- History.txt
-- LICENSE.txt
-- Manifest.txt
-- README.txt
+- LICENSE
+- README.md
 files: 
-- History.txt
-- LICENSE.txt
+- CHANGELOG.md
+- LICENSE
 - Manifest.txt
-- README.txt
+- README.md
 - Rakefile
+- VERSION
 - examples/arrays.rb
+- examples/buckets.rb
 - examples/colors.rb
 - examples/nested.rb
-- examples/zones.rb
+- interpolate.gemspec
 - lib/interpolate.rb
-- lib/interpolate/add/array.rb
 - lib/interpolate/add/core.rb
-- lib/interpolate/add/numeric.rb
+- lib/interpolate/add/core/array.rb
+- lib/interpolate/add/core/numeric.rb
+- lib/interpolate/interpolation.rb
 - test/test_all.rb
 has_rdoc: true
-homepage: http://interpolate.rubyforge.org
+homepage: http://github.com/m104/interpolate
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --main
-- README.txt
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
-rubyforge_project: interpolate
-rubygems_version: 1.3.5
+rubyforge_project: 
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: 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.
+summary: Create linear interpolations from key points and values
 test_files: 
+- examples/arrays.rb
+- examples/buckets.rb
+- examples/colors.rb
+- examples/nested.rb
 - test/test_all.rb

data/examples/zones.rb

@@ -1,28 +0,0 @@
-require 'rubygems'
-require 'interpolate'
-
-points = {
-  0.000 => 0,
-  0.427 => 1,
-  1.200 => 2,
-  3.420 => 3,
-  27.50 => 4,
-  45.20 => 5,
-  124.4 => 6,
-}
-
-zones = Interpolation.new(points)
-
-values = [
-  -20.2,
-  0.234,
-  65.24,
-  9.234,
-  398.4,
-  4000
-]
-
-values.each do |value|
-  zone = zones.at(value).floor
-  puts "A value of #{value} falls into zone #{zone}"
-end