interpolator 0.13 → 0.14

data/interpolator.rb

@@ -22,6 +22,9 @@
 # OTHER DEALINGS IN THE SOFTWARE.
 #
 #
+# More information, source code and gems @ http://rubyforge.org/projects/interpolator/
+#
+#
 module Interpolator
 
 # Table holds a series of independent and dependent values that can be interpolated or extrapolated.
@@ -30,7 +33,12 @@ module Interpolator
 # created.
 #
 # Tables can be told to not extrapolate by setting .extrapolate=false
-# The interpolation method is controlled with .style = LINEAR,LAGRANGE2, or LAGRANGE3
+# The interpolation method is controlled with .style = LINEAR, LAGRANGE2, LAGRANGE3, CUBIC (also known as natural spline), or CATMULL (spline)
+#
+# The style and extrapolate attributes are only applied to that specific Table. They are not propagated to subtables. Each subtable
+# can of course accept it's own attributes.
+#
+# More information, source code and gems @ http://rubyforge.org/projects/interpolator/
 #
     class Table
     
@@ -40,10 +48,12 @@ module Interpolator
        LINEAR    = 1
        LAGRANGE2 = 2
        LAGRANGE3 = 3
-
+       CUBIC     = 4
+       CATMULL   = 5
+#
 # Tables are constructed from either a pair of Arrays or a single Hash.
 #     
-# The 2 argument constructor accepts and array of independents and an array of dependents. The
+# The 2 argument constructor accepts an array of independents and an array of dependents. The
 # independent Array should be floating point values. The dependent Array can be either floating
 # point values or Tables (aka sub tables.) There is no limit to how deep a Table can be.
 #     
@@ -80,6 +90,10 @@ module Interpolator
 #                      5=>Table.new([11.0,12.0,13.0],[-14.0,-15.0,-16.0]))
 #                  )
 #
+#             Note: notice how the Hash version of the table constructor makes it easier to view multidimensional Tables.
+#
+#
+# The amount of Table nesting is only limited by RAM.
 #
 # As a convienance the constructor accepts a block and will pass back the
 # Table instance. This makes it easy to set the style and extrapolation inline.
@@ -105,17 +119,20 @@ module Interpolator
            end
     
            raise "number of independents must equal the number of dependents" unless @inds.size == @deps.size
-           ilast = nil
+           ii = nil
            @inds.each do |i|
-             raise "independents must be monotonically increasing" unless (ilast == nil || i > ilast)
-             ilast = i
+             raise "independents must be monotonically increasing" unless (ii == nil || i > ii)
+             ii = i
            end
            @extrapolate = true
            @style       = LINEAR
+           @ilast       = 0    # index of last bracket operation. theory is subsequent table reads may be close to this index so remember it
+           @secderivs   = []
            if block_given? 
              yield self  # makes it easy for users to set Table attributes inline
            end
        end
+#
 # Interpolate or extrapolate the Table. Pass as many arguments as there are independent dimensions to the table (univariant a
 # single argument, bivariant 2 arguments, etc.)
 #   
@@ -133,51 +150,31 @@ module Interpolator
           raise "table requires at least 2 points for linear interpolation" if (@style == LINEAR && @inds.size<2)
           raise "table requires at least 3 points for lagrange2 interpolation" if (@style == LAGRANGE2 && @inds.size<3)
           raise "table requires at least 4 points for lagrange3 interpolation" if (@style == LAGRANGE3 && @inds.size<4)
+          raise "table requires at least 3 points for cubic spline interpolation" if (@style == CUBIC && @inds.size<3)
+          raise "table requires at least 2 points for catmull-rom interpolation" if (@style == CATMULL && @inds.size<2)
           raise "insufficient number of arguments to read table" unless args.size>=1
+          raise "insufficient number of arguments to read table" if (args.size==1 && @deps[0].kind_of?(Table))
+          raise "too many arguments to read table" if (args.size>1 && !@deps[0].kind_of?(Table))
              
           xval = args[0]
+          subargs = args[1..-1]
           
           if (@extrapolate == false) && (xval < @inds[0]) then
-              if (args.size==1) then
-                ans = @deps[0]
-              else
-                subargs = args[1..-1]
-                tab = @deps[0]
-                ans = tab.read(*subargs)
-              end
+              ans = subread(0,*subargs)
           
           elsif (@extrapolate == false) && (xval > @inds[-1]) 
-              if (args.size==1) then
-                ans = @deps[-1]
-              else
-                subargs = args[1..-1]
-                tab = @deps[-1]
-                ans = tab.read(*subargs)
-              end
-          
+              ans = subread(-1,*subargs)
+
           else
-       
               ileft = bracket(xval)
           
               case @style
               when LINEAR
                  x1 = @inds[ileft]
                  x2 = @inds[ileft+1]
-                 if (args.size==1) then
-                    # return the answer
-                      y1 = @deps[ileft]
-                      y2 = @deps[ileft+1]
-                      ans = linear(xval,x1,x2,y1,y2)
-                 else
-                    # interpolate the sub tables
-                      tab1 = @deps[ileft]
-                      tab2 = @deps[ileft+1]
-                      subargs = args[1..-1]
-                      y1 = tab1.read(*subargs)
-                      y2 = tab2.read(*subargs)
-                      ans = linear(xval,x1,x2,y1,y2)
-                 end            
-              
+                 y1 = subread(ileft,*subargs)
+                 y2 = subread(ileft+1,*subargs)
+                 ans = linear(xval,x1,x2,y1,y2)            
               when LAGRANGE2
                  indx = ileft
                  if ileft == @inds.size-2    
@@ -186,24 +183,11 @@ module Interpolator
                  x1 = @inds[indx]
                  x2 = @inds[indx+1]
                  x3 = @inds[indx+2]
-                 if (args.size==1) 
-                    # return the answer
-                      y1 = @deps[indx]
-                      y2 = @deps[indx+1]
-                      y3 = @deps[indx+2]
-                      ans = lagrange2(xval,x1,x2,x3,y1,y2,y3)
-                 else
-                    # interpolate the sub tables
-                      tab1 = @deps[indx]
-                      tab2 = @deps[indx+1]
-                      tab3 = @deps[indx+2]
-                      subargs = args[1..-1]
-                      y1 = tab1.read(*subargs)
-                      y2 = tab2.read(*subargs)
-                      y3 = tab3.read(*subargs)
-                      ans = lagrange2(xval,x1,x2,x3,y1,y2,y3)
-                 end                  
-              
+                 y1 = subread(indx,*subargs)
+                 y2 = subread(indx+1,*subargs)
+                 y3 = subread(indx+2,*subargs)
+                 ans = lagrange2(xval,x1,x2,x3,y1,y2,y3)
+           
               when LAGRANGE3
                  indx = ileft
                  if (ileft > @inds.size-3) 
@@ -215,26 +199,39 @@ module Interpolator
                  x2 = @inds[indx]
                  x3 = @inds[indx+1]
                  x4 = @inds[indx+2]
-                 if (args.size==1) then
-                    # return the answer
-                      y1 = @deps[indx-1]
-                      y2 = @deps[indx]
-                      y3 = @deps[indx+1]
-                      y4 = @deps[indx+2]
-                      ans = lagrange3(xval,x1,x2,x3,x4,y1,y2,y3,y4)
-                 else
-                    # interpolate the sub tables
-                      tab1 = @deps[indx-1]
-                      tab2 = @deps[indx]
-                      tab3 = @deps[indx+1]
-                      tab4 = @deps[indx+2]
-                      subargs = args[1..-1]
-                      y1 = tab1.read(*subargs)
-                      y2 = tab2.read(*subargs)
-                      y3 = tab3.read(*subargs)
-                      y4 = tab4.read(*subargs)
-                      ans = lagrange3(xval,x1,x2,x3,x4,y1,y2,y3,y4)
-                 end                               
+                 y1 = subread(indx-1,*subargs)
+                 y2 = subread(indx,*subargs)
+                 y3 = subread(indx+1,*subargs)
+                 y4 = subread(indx+2,*subargs)
+                 ans = lagrange3(xval,x1,x2,x3,x4,y1,y2,y3,y4)
+
+              when CUBIC
+                 indx = ileft
+                 x1 = @inds[indx]
+                 x2 = @inds[indx+1]
+                 y1 = subread(indx,*subargs)
+                 y2 = subread(indx+1,*subargs)
+                 ans = cubic(xval,indx,x1,x2,y1,y2,*subargs)
+
+              when CATMULL
+                 indx = ileft
+                 tinds = @inds.dup              # were gonna prepend and append 2 control points temporarily
+                 tdeps = @deps.dup                 
+                 tinds.insert(0,@inds[0])
+                 tinds << @inds[-1]
+                 tdeps.insert(0,@deps[0])
+                 tdeps << @deps[-1]
+                 indx=indx+1
+                 x0 = tinds[indx-1]
+                 x1 = tinds[indx]
+                 x2 = tinds[indx+1]
+                 x3 = tinds[indx+2]
+                 y0 = catsubread(indx-1,tdeps,*subargs)
+                 y1 = catsubread(indx,tdeps,*subargs)
+                 y2 = catsubread(indx+1,tdeps,*subargs)
+                 y3 = catsubread(indx+2,tdeps,*subargs)                 
+                 ans = catmull(xval,x0,x1,x2,x3,y0,y1,y2,y3)
+                 
               else
                  raise("invalid interpolation type")
               end
@@ -245,28 +242,54 @@ module Interpolator
 #
 #  Same as read
 #
-       def interpolate(*args)
-          read(*args)
-       end  
+       alias_method :interpolate,:read
        
        protected
+       
+       def subread (i,*subargs)
+          if subargs == []
+             @deps[i]
+          else
+             @deps[i].read(*subargs)
+          end
+       end
+       def catsubread (i,tdeps,*subargs)
+          if subargs == []
+             tdeps[i]
+          else
+             tdeps[i].read(*subargs)
+          end
+       end
 
-# replace later with a high speed bisection
 
+#
+# high speed bracket via last index and bisection
+# 
        def bracket (x)
-           ileft=0
-           for i in (0..@inds.size-2) do
-              ileft=i
-              if ( (x >= @inds[i]) && (x < @inds[i+1]) ) then
-                  break
-              end
+           if (x<=@inds[0])
+               @ilast=0
+           elsif (x>=@inds[-2])
+               @ilast = @inds.size-2
+           else   
+               low  = 0
+               high = @inds.size-1
+               while !(x>=@inds[@ilast] && x<@inds[@ilast+1])
+                  if (x>@inds[@ilast])
+                     low    =  @ilast + 1
+                     @ilast = (high - low) / 2 + low
+                  else
+                     high    =  @ilast - 1
+                     @ilast = high - (high - low) / 2                  
+                  end
+               end
            end
-           ileft
+           @ilast
        end
        
        def linear (x,x1,x2,y1,y2)
          r = (y2-y1) / (x2-x1) * (x-x1) + y1
        end
+       
        def lagrange2(x,x1,x2,x3,y1,y2,y3)   
          c12 = x1 - x2
          c13 = x1 - x3
@@ -279,6 +302,7 @@ module Interpolator
          xx3 = x - x3
          r = xx3*(q1*xx2 - q2*xx1) + q3*xx1*xx2
        end
+       
        def lagrange3(x,x1,x2,x3,x4,y1,y2,y3,y4)
          c12 = x1 - x2
          c13 = x1 - x3
@@ -297,6 +321,53 @@ module Interpolator
          r = xx4*(xx3*(q1*xx2 - q2*xx1) + q3*xx1*xx2) - q4*xx1*xx2*xx3
        end
        
+       def catmull(xval,x0,x1,x2,x3,y0,y1,y2,y3)
+            m0 = (y2-y0)/(x2-x0)
+            m1 = (y3-y1)/(x3-x1)
+            h  = x2-x1
+            t  = (xval - x1)/h
+            h00 = 2.0*t**3 - 3.0*t**2+1.0
+            h10 = t**3-2.0*t**2+t
+            h01 = -2.0*t**3+3.0*t**2
+            h11 = t**3-t**2
+            ans = h00*y1+h10*h*m0+h01*y2+h11*h*m1
+       end
+       
+       def cubic(x,indx,x1,x2,y1,y2,*subargs)
+         if @secderivs == []
+           @secderivs = second_derivs(*subargs)  # this is painful so lets just do it once
+         end
+         step = x2 - x1
+         a = (x2 - x) / step
+         b = (x - x1) / step
+         r = a * y1 + b * y2 + ((a*a*a-a) * @secderivs[indx] + (b*b*b-b) * @secderivs[indx+1]) * (step*step) / 6.0
+       end
+       
+       def second_derivs(*subargs)
+        # natural spline has 0 second derivative at the ends
+         temp   = [0.0]
+         secder = [0.0]
+         if subargs.size==0
+           deps2 = @deps
+         else
+           deps2 = @deps.map do |a|
+              a.read(*subargs)
+           end
+         end
+         1.upto(@inds.size-2) do |i|
+            sig  = (@inds[i] - @inds[i-1])/(@inds[i+1] - @inds[i-1])
+            prtl = sig * secder[i-1] + 2.0
+            secder << (sig-1.0)/prtl
+            temp << ((deps2[i+1]-deps2[i])/(@inds[i+1]-@inds[i]) - (deps2[i]-deps2[i-1])/(@inds[i]-@inds[i-1]))
+            temp[i]=(6.0*temp[i]/(@inds[i+1]-@inds[i-1])-sig*temp[i-1])/prtl
+         end
+        # natural spline has 0 second derivative at the ends
+         secder << 0.0
+         (@inds.size-2).downto(0) do |i|
+            secder[i]=secder[i]*secder[i+1]+temp[i]
+         end
+         secder
+       end
     end
 
 if __FILE__ == $0 then
@@ -311,25 +382,35 @@ require 'test/unit'
        @t2 = Table.new([1.0,2.0],[Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0])])
        @t3 = Table.new [1.0,2.0],[3.0,4.0]
        @t4 = Table.new(
-               1=>Table.new(
-                 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
-                 4=>Table.new([11.0,12.0,13.0],[14.0,15.0,16.0]),
-                 5=>Table.new([11.0,12.0,13.0],[-14.0,-15.0,-16.0])),
-               2=>Table.new(
-                 2=>Table.new([1.1,2.0,3.0],[4.0,5.0,6.0]),
-                 5=>Table.new([11.0,12.5,13.0],[14.0,15.0,16.0]),
-                 6.2=>Table.new([1.0,12.0],[-14.0,-16.0])),
-               8=>Table.new(
-                 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
-                 5=>Table.new([11.0,12.0,13.0],[-14.0,-15.0,-16.0]))
+               1.0=>Table.new(
+                 1.0=>Table.new([1.0,2.0,3.0],
+                                [4.0,5.0,6.0]),
+                 4.0=>Table.new([11.0,12.0,13.0],
+                                [14.0,15.0,16.0]),
+                 5.0=>Table.new([11.0,12.0,13.0],
+                                [-14.0,-15.0,-16.0])),
+               2.0=>Table.new(
+                 2.0=>Table.new([1.1,2.0,3.0],
+                                [4.0,5.0,6.0]),
+                 5.0=>Table.new([11.0,12.5,13.0],
+                                [14.0,15.0,16.0]),
+                 6.2=>Table.new([1.0,12.0],
+                                [-14.0,-16.0])),
+               8.0=>Table.new(
+                 1.0=>Table.new([1.0,2.0,3.0],
+                                [4.0,5.0,6.0]),
+                 5.0=>Table.new([11.0,12.0,13.0],
+                                [-14.0,-15.0,-16.0]))
              )
        @t5 = Table.new [1.0,2.0,3.0],[1.0,4.0,9.0]     
        @t6 = Table.new [1.0,2.0,3.0,4.0],[1.0,8.0,27.0,64.0]     
+       @t7 = Table.new [0.0,0.8,1.9,3.1,4.2,5.0],[1.0,1.0,1.0,2.0,2.0,2.0]
+       @t8 = Table.new [0.0,1.0,2.0,3.0,4.0,5.0,6.0],[0.0,0.8415,0.9093,0.1411,-0.7568,-0.9589,-0.2794]
+       @t9 = Table.new([1.0,2.0,3.0],
+                       [Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0]),Table.new([4.0,5.0,6.0],[7.0,8.0,9.0])])
+       @t10 = Table.new [1.5,2.0,3.0,4.0],[4.0,5.0,6.0,7.0]
       end
 
-      # def teardown
-      # end
-
       def test_uni
         assert_equal(@t1.read(1.0) ,     3.0)
         assert_equal(@t1.read(2.0) ,     4.0)
@@ -375,7 +456,9 @@ require 'test/unit'
          assert_raise( RuntimeError ) {@t3.read(1.0)}    
          @t3.style=Table::LAGRANGE3
          assert_raise( RuntimeError ) {@t3.read(1.0)} 
-         @t3.style=Table::LINEAR
+         @t3.style=Table::CUBIC
+         assert_raise( RuntimeError ) {@t3.read(1.0)} 
+         @t3.style=Table::LINEAR         
          assert_nothing_raised( RuntimeError ) {@t3.read(1)}         
       end
       def test_notmono
@@ -404,19 +487,41 @@ require 'test/unit'
          assert_raise( RuntimeError ) {
            t = Table.new [1.0,-2.0,1.5],[1.0,2.0,3.0]
            t.style=10
-           t.read(1)
+           t.read(1.0)
          }
+         @t7.style = Table::CUBIC
+         assert_in_delta(0.93261392,@t7.read(1.2),0.000001)
+         @t8.style = Table::CUBIC
+         assert_in_delta(0.59621,@t8.read(2.5),0.000001)
+         @t9.style = Table::CUBIC
+         assert_in_delta(8.98175,@t9.read(2.3,1.5),0.000001)
+         @t10.style=Table::CATMULL
+         assert_in_delta(3.666666,@t10.read(1.0),0.00001)
+         assert_in_delta(5.5416666,@t10.read(2.5),0.00001)
+         assert_in_delta(6.0,@t10.read(0.5),0.00001)
+         assert_in_delta(8.0,@t10.read(5.0),0.00001)
+         assert_in_delta(6.5,@t10.read(3.5),0.00001)
+         assert_in_delta(4.8427,@t10.read(1.9),0.0001)
+         @t10.extrapolate=false
+         assert_equal(4.0,@t10.read(1.0))
+         assert_equal(7.0,@t10.read(99.0))
       end
       def test_block
         t = Table.new [1.0,2.0,3.0],[3.0,4.0,5.0] do |tab| tab.extrapolate=false;tab.style=Table::LAGRANGE2 end
         assert_equal(t.read(4.0),5.0)
       end
+      def test_alias
+        assert_equal(@t1.read(1.5),@t1.interpolate(1.5))
+      end
+      def test_numargs
+        assert_raise( RuntimeError ) {@t1.read}
+        assert_raise( RuntimeError ) {@t2.read(1.0)}
+        assert_raise( RuntimeError ) {@t2.read(1.0,1.0,1.0)}
+        assert_nothing_raised( RuntimeError ) {@t2.read(1.0,1.0)}
+      end
       
     end
     
+ end
 
 end
-
-
-end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: interpolator
 version: !ruby/object:Gem::Version 
-  version: "0.13"
+  version: "0.14"
 platform: ruby
 authors: 
 - Eric T Meyers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-08 00:00:00 -04:00
+date: 2009-08-15 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -51,6 +51,6 @@ rubyforge_project: interpolator
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Module Interpolator proves a table class that supports n-dimensional numerical table construction, interpolation and extrapolation. Includes linear, 2nd order and 3rd order la grange techniques.
+summary: Module Interpolator proves a table class that supports n-dimensional numerical table construction, interpolation and extrapolation. Includes linear, 2nd order and 3rd order lagrange, natural and catmull-rom spline techniques.
 test_files: []