interpolator 0.11

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Eric Todd Meyers
+
+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 IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/interpolator.rb

@@ -0,0 +1,320 @@
+module Interpolator
+
+    class Table
+    
+       attr_reader :extrapolate,:style
+       attr_writer :extrapolate,:style
+    
+       LINEAR    = 1
+       LAGRANGE2 = 2
+       LAGRANGE3 = 3
+    
+       def initialize (*args)
+    
+           if (args.size==2) then
+               raise "duel argument table constructor must be 2 Arrays" unless args[0].kind_of? Array
+               raise "duel argument table constructor must be 2 Arrays" unless args[1].kind_of? Array
+               @inds = args[0]          # better be numbers
+               @deps = args[1]          # can either be numbers or sub tables
+           elsif (args.size == 1) then  # hash version
+               raise "single argument table constructor must be a Hash" unless args[0].kind_of? Hash
+               # Ruby 1.8 doesnt maintain hash order so lets help it
+               f = args[0].sort.transpose
+               @inds = f[0]
+               @deps = f[1]               
+           else
+               raise(args.size.to_s + " argument Table constructor not valid");
+           end
+    
+           raise "number of independents must equal the number of dependents" unless @inds.size == @deps.size
+           ilast = nil
+           @inds.each do |i|
+             raise "independents must be monotonically increasing" unless (ilast == nil || i > ilast)
+             ilast = i
+           end
+           @extrapolate = true
+           @style       = LINEAR
+       end
+
+# replace later with a high speed 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
+           end
+           ileft
+       end
+
+       def read(*args)
+    
+          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 "insufficient number of arguments to read table" unless args.size>=1
+             
+          xval = args[0]
+          
+          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
+          
+          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
+          
+          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            
+              
+              when LAGRANGE2
+                 indx = ileft
+                 if ileft == @inds.size-2    
+                    indx = ileft - 1    
+                 end
+                 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                  
+              
+              when LAGRANGE3
+                 indx = ileft
+                 if (ileft > @inds.size-3) 
+                    indx = @inds.size - 3;
+                 elsif (ileft  == 0) 
+                    indx = ileft + 1
+                 end   
+                 x1 = @inds[indx-1]
+                 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                               
+              else
+                 raise("invalid interpolation type")
+              end
+          end
+          ans
+       end
+       
+       def interpolate(*args)
+          read(*args)
+       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
+         c23 = x2 - x3
+         q1 = y1/(c12*c13)
+         q2 = y2/(c12*c23)
+         q3 = y3/(c13*c23)
+         xx1 = x - x1
+         xx2 = x - x2
+         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
+         c14 = x1 - x4
+         c23 = x2 - x3
+         c24 = x2 - x4
+         c34 = x3 - x4
+         q1 = y1/(c12 * c13 * c14)
+         q2 = y2/(c12 * c23 * c24)
+         q3 = y3/(c13 * c23 * c34)
+         q4 = y4/(c14 * c24 * c34)
+         xx1 = x - x1
+         xx2 = x - x2
+         xx3 = x - x3
+         xx4 = x - x4
+         r = xx4*(xx3*(q1*xx2 - q2*xx1) + q3*xx1*xx2) - q4*xx1*xx2*xx3
+       end
+       
+    end
+
+if __FILE__ == $0 then
+
+require 'test/unit'
+
+    class TC_LookupTest < Test::Unit::TestCase
+      def setup
+       @t1 = Table.new [1.0,2.0],[3.0,4.0]
+       @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]))
+             )
+       @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]     
+      end
+
+      # def teardown
+      # end
+
+      def test_uni
+        assert_equal(@t1.read(1.0) ,     3.0)
+        assert_equal(@t1.read(2.0) ,     4.0)
+        assert_equal(@t1.read(1.5) ,     3.5)
+      end
+      def test_bi
+        assert_equal(@t2.read(1.0,1.0) ,   3.0)
+        assert_equal(@t2.read(2.0,3.0) ,  -1.0)
+        assert_equal(@t2.read(1.5,2.0) ,   5.0)
+      end
+      def test_tri
+        assert_equal(@t4.read(1.5,5,13),0.0)
+      end
+      def test_create
+        assert_nothing_raised{
+            Table.new(1.0=>3.0,2.0=>4.0)
+        }
+        assert_nothing_raised( RuntimeError ){
+            Table.new 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
+                      2=>Table.new([2.0,4.0,7.0],[14.0,15.0,16.0])
+         }
+        assert_nothing_raised( RuntimeError ){
+            Table.new 1=>Table.new(
+                          [1.0,2.0,3.0],
+                          [4.0,5.0,6.0]),
+                      2=>Table.new(
+                          [2.0,4.0,7.0],
+                          [14.0,15.0,16.0])
+         }
+        assert_nothing_raised( RuntimeError ){
+            Table.new 1=>Table.new(
+                          1.0=>4.0,
+                          2.0=>5.0,
+                          3.0=>6.0),
+                      2=>Table.new(
+                          [2.0,4.0,7.0,12.0],
+                          [14.0,15.0,16.0,-4.0])
+         }
+         assert_raise( RuntimeError ) {Table.new(1,2,3)}
+      end
+      def test_size
+         @t3.style=Table::LAGRANGE2
+         assert_raise( RuntimeError ) {@t3.read(1.0)}    
+         @t3.style=Table::LAGRANGE3
+         assert_raise( RuntimeError ) {@t3.read(1.0)} 
+         @t3.style=Table::LINEAR
+         assert_nothing_raised( RuntimeError ) {@t3.read(1)}         
+      end
+      def test_notmono
+        assert_raise( RuntimeError ) {Table.new [1.0,2.0,1.5],[1.0,2.0,3.0]}
+        assert_raise( RuntimeError ) {Table.new [1.0,-2.0,1.5],[1.0,2.0,3.0]}
+      end
+      def test_extrap
+        @t1.extrapolate = false
+        assert_equal(@t1.read(0.0) ,   3.0)        
+        assert_equal(@t1.read(3.0) ,   4.0)        
+        @t1.extrapolate = true
+        assert_equal(@t1.read(0.0) ,   2.0)
+        assert_equal(@t1.read(3.0) ,   5.0)
+      end
+      def test_style
+         @t5.style=Table::LAGRANGE2
+         assert_equal(@t5.read(2.0),4.0)
+         assert_equal(@t5.read(2.5),2.5*2.5)
+         @t6.style=Table::LAGRANGE3
+         assert_equal(@t6.read(2.0),8.0)
+         assert_equal(@t6.read(3.5),3.5*3.5*3.5)         
+         @t5.style=Table::LINEAR
+         assert_equal(@t5.read(1.5),2.5)
+         @t6.style=Table::LINEAR
+         assert_equal(@t6.read(1.5),4.5)
+         assert_raise( RuntimeError ) {
+           t = Table.new [1.0,-2.0,1.5],[1.0,2.0,3.0]
+           t.style=10
+           t.read(1)
+         }
+      end
+      
+    end
+
+end
+
+
+end
+
+
+

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+name: interpolator
+version: !ruby/object:Gem::Version 
+  version: "0.11"
+platform: ruby
+authors: 
+- Eric T Meyers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-02 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: n-dimensional table interpolation
+email: etm@ericmeyers.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- interpolator.rb
+- LICENSE
+has_rdoc: true
+homepage: http://interpolator.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: interpolator
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Module Interpolation proves a table class that supports n-dimensional numerical table construction, interpolation and extrapolation. Includes linear, 2nd order and 3rd order la grange techniques.
+test_files: []
+