interpolation 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 736c1de695651f5d9b074dbc0e4dfe56614c3ad4
-  data.tar.gz: 4ce0806e958fbff6c78fbe94992f0f8259f46955
+  metadata.gz: b7fc3cc6ff6163f8b9471a7a2b858426868d0b03
+  data.tar.gz: 47cf81100158e19aae3e99610c552c41c2df545b
 SHA512:
-  metadata.gz: ce4fe2d42c2bf757b8cea3b647c754e7797878ad22c29fd1ae388b9b9a4a55d80f21015bb5f590b9dcd3fb70869e27d21f421ca529e4f2bfa5b378dfbe57440a
-  data.tar.gz: 9bc487d1338da2ecfd509028d9b9fdbc4962f2e54b525d821bd403c5b2af1009b3b423ab87f0cd20814d5b2d36cf3a83b5c2560927a0abef5b1fc4b89cbb6cb2
+  metadata.gz: 3c81a2efcec63b92ff04b50a9cd73dc790af2465878ca99e568e50590467e4426c68d611e04c5d4f63d5d7f315cb4953be79faf60f0ca431e4ea4f8f650a62a7
+  data.tar.gz: 09583536302d4b8fe3670008302e643b4b2f02b60754937c96e7406112225da191df03c31aebe8573db041d5e00cddb7d40d54ef5fb6cfb18f18ca6832370708

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile.lock

@@ -1,8 +1,7 @@
 PATH
   remote: .
   specs:
-    interpolation (0.0.1)
-      nmatrix (~> 0.1.0.rc5)
+    interpolation (0.0.2)
 
 GEM
   remote: https://rubygems.org/
@@ -32,5 +31,6 @@ PLATFORMS
 
 DEPENDENCIES
   interpolation!
+  nmatrix (~> 0.1.0.rc5)
   rake
   rspec

data/README.md

@@ -2,3 +2,21 @@ interpolation
 =============
 
 Interpolation routines for ruby.
+
+Note : This library is still under development and currently does not support a lot of interpolation routines.
+
+Supports the following 1D interpolation routines:
+* Linear interpolation
+* Cubic spline interpolation
+
+## Usage
+
+See the documentation for detailed examples.
+
+## Roadmap
+
+* Support polynomial interpolation.
+* N-dimensional interpolation routines.
+* Optional fast data manipulation with NMatrix.
+* Easy plotting of results.
+* Complete NMatrix integration.

data/interpolation.gemspec

@@ -20,6 +20,4 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
-
-  gem.add_runtime_dependency 'nmatrix', '~> 0.1.0.rc5'
 end

data/lib/interpolation.rb

@@ -1,5 +1,19 @@
+#--
+# = Interpolation 
+# Copyright (c) 2014, Sameer Deshmukh
+# All rights reserved.
+#   
+# Interpolation is a library for executing various interpolation 
+# functions in Ruby.
+# 
+# == spec/lib/1d_interpolation_spec.rb
+#
+# Tests for 1D interpolation.
+#++
+
 require 'nmatrix'
 
 $:.unshift File.dirname(__FILE__)
 
-require 'interpolation/one_dimensional.rb'
+require 'interpolation/one_dimensional.rb'
+require 'monkeys.rb'

data/lib/interpolation/base.rb

@@ -1,37 +1,31 @@
 #--
-# = Interpolation
+# = Interpolation 
+# Copyright (c) 2014, Sameer Deshmukh
+# All rights reserved.
 #   
 # Interpolation is a library for executing various interpolation 
-# functions in Ruby. Works with NMatrix.
+# functions in Ruby.
 # 
-# == interpolation/base.rb
+# == spec/lib/1d_interpolation_spec.rb
 #
-# Base class for all interpolation methods.
+# Tests for 1D interpolation.
 #++
 
 module Interpolation
   class Base
     def initialize x, y, opts
-      @x, @y, @opts = x, y, opts
+      @x, @y = x, y
 
-      raise ArgumentError, "Specify the kind of interpolation?" if !@opts[:kind]
-      raise DataTypeError, "Invalid data type of x/y" if !valid_dtypes?
-      raise ArgumentError, "Axis specified out of bounds" if invalid_axis?
-
-      @opts[:precision] = 3 if !@opts[:precision]
-
-      axis  = (@opts[:axis] ? @opts[:axis] : 0)
+      @opts = {
+        precision: 3,
+        sorted: false,
+        type: :linear
+      }.merge(opts)
 
       @size = @x.size # considers size of @x only
       @x    = @x.sort unless @opts[:sorted]
+      @x.map! { |n| n = Float(n)}
     end
-   private
-
-    def valid_dtypes?
-      (@x.is_a?(Array) or @x.is_a?(NMatrix)) and
-      (@y.is_a?(Array) or @y.is_a?(NMatrix))
-    end
-
    protected
 
     def locate num 
@@ -50,15 +44,9 @@ module Interpolation
         end
       end
 
-      if    num == @x[0]       then return 0
-      elsif num == @x[@size-1] then return @size-2
-      else                          return jl
-      end
+      return 0       if    num == @x[0]
+      return @size-2 if    num == @x[@size - 1]
+      return jl                           
     end 
-
-    def invalid_axis?
-      @opts[:axis] and @opts[:axis] > @y.cols-1
-    end
-
   end
 end

data/lib/interpolation/one_dimensional.rb

@@ -1,16 +1,18 @@
-$:.unshift File.dirname(__FILE__)
-
 #--
-# = Interpolation
+# = Interpolation 
+# Copyright (c) 2014, Sameer Deshmukh
+# All rights reserved.
 #   
 # Interpolation is a library for executing various interpolation 
-# functions in Ruby. Works with NMatrix.
+# functions in Ruby.
 # 
-# == interpolation/one_dimensional.rb
+# == spec/lib/1d_interpolation_spec.rb
 #
-# Methods for performing one dimensional interpolation.
+# Tests for 1D interpolation.
 #++
 
+$:.unshift File.dirname(__FILE__)
+
 require 'base.rb'
 
 module Interpolation
@@ -19,15 +21,24 @@ module Interpolation
   # 
   # ==== Usage
   # 
-  # x = NMatrix.seq [10]
+  # x = (1..10).step(1).to_a
   # y = x.exp
   # 
-  # f = NMatrix::Interpolation::OneDimensional.new x, y, {kind: :linear, sorted: true}
+  # f = Interpolation::OneDimensional.new x, y, {kind: :linear, sorted: true}
   # i = f.interpolate 2.5
   # 
   # puts "Interpolated value for 2.5 is #{i}"
   class OneDimensional < Interpolation::Base
 
+    # !@attribute return_type
+    #   The data type of the returned data. Set to :array, :matrix, nmatrix.
+    #   :array by default (only supports Arrray as of now).
+    #   @return [Array]   Returns data as a ruby Array if set to :array
+    #   @return [Matrix]  Returns data as a ruby Matrix if set to :matrix
+    #   @return [NMatrix] Returns data as an NMatrix if set to :nmatrix. Needs 
+    #   the NMatrix gem installed.
+    attr_writer :return_type
+
     # Constructor for all One Dimensional interpolation operations.
     # 
     # The function values to be supplied to this class are of the form y = f(x). 
@@ -45,28 +56,41 @@ module Interpolation
     #            multiple columns, the interpolation is carried out on each column,
     #            unless specified.
     # 
-    # * +opts+ - Various options for carrying out the interpolation, to be specified as
-    #            a hash.
+    # * +opts+ - Various options for carrying out the interpolation.
     # 
     # ==== Options
     # 
-    # * +:kind+ - The kind of interpolation that the user wants to perform. Should be 
-    #             specified as a symbol. This option is compulsory. Only linear
-    #             interpolation supported as of now. 
+    # * +:type+ - The kind of interpolation that the user wants to perform. Should be 
+    #             specified as a symbol. Defaults to linear. Only linear and cubic
+    #             interpolation supported as of now. Cubic interpolation done with splines.
     # 
     # * +:sorted+ - Set this option as *true* if the absicca collection is supplied in
     #             the arguments in a sorted manner. If not supplied, it will be assumed
     #             that absiccas are not sorted and they will sorted be sorted anyway.
     # 
     # * +:axis+ - In case of a multidimensional ordinate matrix, specify the column over
-    #             which interpolation must be performed. *axis* starts indexing from 0 
-    #             and should be lower than the number of columns in the ordinate matrix.
-    # 
+    # which interpolation must be performed. *axis* starts indexing from 0 and should be 
+    # lower than the number of columns in the ordinate matrix.
+    #             
     # * +:precision+ - Specifies the precision of the interpolated values returned. Defaults
-    #             to 3.
+    # to 3.
+    # 
+    # * +:yp1+ - First derivative of the 0th point (cubic spline).
+    # 
+    # * +:ypn+ - First derivative of the last (n-1)th point (cubic spline).
     # 
+    # == Usage
+    #   
+    #   x = (0..9).step(1).to_a
+    #   y = x.map { |n| Math.exp(n) }
+    #   f = Interpolation::OneDimensional.new x,y, type: :cubic
+    #   f.interpolate 2.5
+    #     #=> 12.287
     def initialize x, y, opts={}
+      @return_type = :array
       super(x,y,opts)
+      
+      compute_second_derivatives if @opts[:type] == :cubic
     end
 
     # Performs the actual interpolation on the value passed as an argument. Kind of 
@@ -81,21 +105,28 @@ module Interpolation
     #                   all its values. Will return answer in the form of an NMatrix if
     #                   *interpolant* is supplied as an NMatrix.
     def interpolate interpolant
-      result = case @opts[:kind]
+      case @opts[:type]
       when :linear
         for_each (interpolant) { |x| linear_interpolation(x)  }
+      when :cubic
+        cubic_spline_interpolation interpolant
       else
-        raise(ArgumentError, "1 D interpolation of kind #{@opts[:kind]} \
-         not supported")
+        raise ArgumentError, "1 D interpolation of type #{@opts[:type]} not supported"
       end
-
-      # return result.to_nm(result.size) if interpolant.is_a?(NMatrix)
-
-      result
     end
 
+    alias_method :[], :interpolate
+
+    # Return the data passed for interpolation alongwith the interpolated values.
+    # @param [Numeric, Array, NMatrix] interpolant the value of the X co-ordinate
+    # @return [Array, NMatrix] returns data based on the value of return_type
+    # def interp interpolant
+            
+    # end
    private
 
+    # Linear interpolation functions
+
     def for_each interpolant
       result = []
 
@@ -137,5 +168,131 @@ module Interpolation
       ((interpolant - @x[index]) / (@x[index + 1] - @x[index])) * 
        (y[index + 1] - y[index])).round(@opts[:precision])
     end
+
+    # Cubic spline interpolation functions
+
+    def compute_second_derivatives
+      @opts.merge!({ 
+        yp1: 1E99, 
+        ypn: 1E99 
+      })  
+
+      if @opts[:axis] == :all
+        compute_multi_axis_second_derivatives
+      else
+        compute_single_axis_second_derivatives
+      end
+    end
+
+    def compute_single_axis_second_derivatives
+      @y_sd = compute_second_derivatives_for(axis_or_array_for(@y))
+    end
+
+    def compute_multi_axis_second_derivatives
+      @y_sd = []
+      @y.each_column do |column|
+        @y_sd << compute_second_derivatives_for(column)
+      end
+
+      @y_sd = Matrix.columns @y_sd
+    end
+
+    def cubic_spline_interpolation interpolant
+      if @opts[:axis] == :all
+        multi_axis_evaluation_for interpolant
+      else
+        single_axis_evaluation_for interpolant
+      end
+    end
+
+    def axis_or_array_for object
+      object.is_a?(Array) ? object : object.column(@opts[:axis])
+    end
+
+    def interpolate_over_all_y_columns interpolant
+      results = []
+      0.upto(@y.column_count - 1) do |col_num|
+        results << evaluate_cubic_spline_polynomial(interpolant, @y.column(col_num), @y_sd.column(col_num))
+      end
+
+      results
+    end
+
+    def multi_axis_evaluation_for interpolant
+      if interpolant.is_a?(Array)
+        interpolant.inject([]) do |acc, int|
+          acc << interpolate_over_all_y_columns(int)
+        end
+      else
+        interpolate_over_all_y_columns interpolant
+      end
+    end
+
+    def single_axis_evaluation_for interpolant
+      y    = axis_or_array_for @y
+      y_sd = axis_or_array_for @y_sd
+
+      if interpolant.is_a?(Array)
+        interpolant.inject([]) do |results, int|
+          results << evaluate_cubic_spline_polynomial(int, y, y_sd)
+        end
+      else
+        evaluate_cubic_spline_polynomial interpolant, y, y_sd
+      end
+    end
+
+    def evaluate_cubic_spline_polynomial interpolant, y, y_sd
+      klo = locate interpolant
+      khi = klo + 1
+
+      h = @x[khi] - @x[klo]
+
+      raise StandardError, "Wrong input at X index #{klo} and #{khi} for cubic spline" if h == 0
+      
+      a = (@x[khi] - interpolant) / h
+      b = (interpolant - @x[klo]) / h
+      (a * y[klo] + b * y[khi] + ((a * a * a - a) * y_sd[klo] +
+        ( b * b * b - b) * y_sd[khi]) * ( h * h ) / 6.0).round(@opts[:precision])
+    end
+
+    # References: Numerical Recipes Edition 3. Chapter 3.3
+    def compute_second_derivatives_for y
+      y_sd = Array.new(@size)
+
+      n      = y_sd.size
+      u      = Array.new(n-1)
+      yp1    = @opts[:yp1] # first derivative of the 0th point as specified by the user
+      ypn    = @opts[:ypn] # first derivative of the nth point as specified by the user
+      qn, un = nil, nil
+
+      if yp1 > 0.99E30
+        y_sd[0], u[0] = 0.0, 0.0
+      else 
+        y_sd[0] = -0.5
+        u[0] = (3.0 / (@x[1] - @x[0])) * ((y[1] - y[0]) / (@x[1] - @x[0]) - yp1)
+      end
+      
+      1.upto(n-2) do |i| # decomposition loop for tridiagonal algorithm
+        sig      = ( @x[i] - @x[i-1] ) / ( @x[i+1] - @x[i-1] )
+        p        = sig * y_sd[i-1] + 2
+        y_sd[i] = ( sig - 1) / p 
+        u[i]     = (( y[i+1] - y[i]) / (@x[i+1] - @x[i])) - ((y[i] - y[i-1]) / (@x[i] - @x[i-1]))
+        u[i]     = ( 6 * u[i] / ( @x[i+1] - @x[i-1] ) - sig * u[i-1] ) / p;
+      end
+
+      if ypn > 0.99E30
+        qn, un = 0.0, 0.0
+      else
+        qn = 0.5
+        un = (3.0 / ( @x[n-1] - @x[n-2] )) * ( ypn - ( y[n-1] - y[n-2] ) / ( @x[n-1] - @x[n-2] ))
+      end
+      y_sd[n-1] = ( un - qn * u[n-2] ) / ( qn * y_sd[n-2] + 1.0 )
+
+      (n-2).downto(0) do |k|
+        y_sd[k] = y_sd[k] * y_sd[k+1] + u[k]
+      end
+
+      y_sd
+    end
   end
 end

data/lib/monkeys.rb

@@ -0,0 +1,5 @@
+class Matrix
+  def each_column(&block)
+    self.column_vectors.each(&block)
+  end  
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Interpolation
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/lib/1d_interpolation_spec.rb

@@ -1,8 +1,10 @@
 #--
-# = Interpolation
+# = Interpolation 
+# Copyright (c) 2014, Sameer Deshmukh
+# All rights reserved.
 #   
 # Interpolation is a library for executing various interpolation 
-# functions in Ruby. Works with NMatrix.
+# functions in Ruby.
 # 
 # == spec/lib/1d_interpolation_spec.rb
 #
@@ -13,66 +15,119 @@ require 'spec_helper.rb'
 
 describe Interpolation::OneDimensional do
   before :each do
-    @x   = NMatrix.seq [10]
-    @y   = @x.exp
-    @nd  = NMatrix.new([10,3]).each_column { |c| c[0..9] = @y }
+    @x  = (0..9).step(1).to_a
+    @y  = @x.map { |e| Math.exp(e) }
+    @nd = Matrix.columns [@y, @y, @y]
   end
 
-  it "tests if OneDimensional accepts Array inputs" do
-    f = Interpolation::OneDimensional.new([0,1,2,3,4,5,6,7,8,9], [1.0, 
-      2.718281828459045, 7.38905609893065, 20.085536923187668, 54.598150033144236, 
-      148.4131591025766, 403.4287934927351, 1096.6331584284585, 2980.9579870417283, 
-      8103.083927575384], {kind: :linear, sorted: true})
+  context :linear do
+    context "#interpolate" do
+      it "interpolates with 1-D ruby Array" do
+        f = Interpolation::OneDimensional.new([0,1,2,3,4,5,6,7,8,9], [1.0, 
+          2.718281828459045, 7.38905609893065, 20.085536923187668, 54.598150033144236, 
+          148.4131591025766, 403.4287934927351, 1096.6331584284585, 2980.9579870417283, 
+          8103.083927575384], {type: :linear, sorted: true})
 
-    expect(f.interpolate(2.5)).to eq 13.737
-  end
+        expect(f.interpolate(2.5)).to eq 13.737
+      end
 
-  it "tests for linear interpolation for 1-dimensional y values" do
-    f = Interpolation::OneDimensional.new(@x, @y, {kind: :linear, 
-      precision: 3})
+      it "interpolates with single axis inout" do
+        f = Interpolation::OneDimensional.new(@x, @y, {type: :linear, 
+          precision: 3})
 
-    expect(f.interpolate(2.5))              .to eq 13.737
+        expect(f.interpolate(2.5))              .to eq 13.737
 
-    expect(f.interpolate([2.5,6.7,0.3,8.6])).to eq [13.737, 888.672, 
-      1.515, 6054.234]
+        expect(f.interpolate([2.5,6.7,0.3,8.6])).to eq [13.737, 888.672, 
+          1.515, 6054.234]
 
-    # expect(f.interpolate(NMatrix.new([4,1], [2.5,6.7,0.3,8.6]))).to eq NMatrix.new(
-    #   [4], [13.737, 888.672, 1.515, 6054.234])
-  end
+        # expect(f.interpolate(NMatrix.new([4,1], [2.5,6.7,0.3,8.6]))).to eq NMatrix.new(
+        #   [4], [13.737, 888.672, 1.515, 6054.234])
+      end
 
-  it "tests linear interpolation for N-dimensional y values" do
+      it "interpolates over all axes" do
+        f = Interpolation::OneDimensional.new(@x,@nd, {type: :linear, 
+          sorted: true, precision: 3})
 
-    f = Interpolation::OneDimensional.new(@x,@nd, {kind: :linear, 
-      sorted: true, precision: 3})
+        expect(f.interpolate(2.5))              .to eq [13.737,13.737,13.737]
+        
+        expect(f.interpolate([2.5,6.7,0.3,8.6])).to eq \
+          [ [13.737  , 13.737  , 13.737 ], 
+            [888.672 , 888.672 , 888.672],
+            [1.515   , 1.515   , 1.515  ],
+            [6054.234, 6054.234, 6054.234 ]
+          ]
 
-    expect(f.interpolate(2.5))              .to eq [13.737,13.737,13.737]
-    
-    expect(f.interpolate([2.5,6.7,0.3,8.6])).to eq \
-      [ [13.737  , 13.737  , 13.737 ], 
-        [888.672 , 888.672 , 888.672],
-        [1.515   , 1.515   , 1.515  ],
-        [6054.234, 6054.234, 6054.234 ]
-      ]
-
-    # expect(f.interpolate(NMatrix.new([4,1], [2.5,6.7,0.3,8.6]))).to eq \
-    #   NMatrix.new([4,3], 
-    #   [ 13.737  , 13.737  , 13.737 , 
-    #     888.672 , 888.672 , 888.672,
-    #     1.515   , 1.515   , 1.515  ,
-    #     6054.234, 6054.234, 6054.234 
-    #   ]) 
+        # expect(f.interpolate(NMatrix.new([4,1], [2.5,6.7,0.3,8.6]))).to eq \
+        #   NMatrix.new([4,3], 
+        #   [ 13.737  , 13.737  , 13.737 , 
+        #     888.672 , 888.672 , 888.672,
+        #     1.515   , 1.515   , 1.515  ,
+        #     6054.234, 6054.234, 6054.234 
+        #   ]) 
+        end
+
+      it "interpolates on specified axis" do
+       f = Interpolation::OneDimensional.new(@x, @nd, {type: :linear, axis: 1, 
+        sorted: true, precision: 3})
+       
+       expect(f.interpolate(3.5))              .to eq 37.342
+
+       expect(f.interpolate([2.5,6.7,0.3,8.6])).to eq [13.737, 888.672, 
+        1.515, 6054.234]
+
+       # expect(f.interpolate(NMatrix.new([4,1], [2.5,6.7,0.3,8.6]))).to eq NMatrix.new(
+       #  [4], [13.737, 888.672, 1.515, 6054.234])
+      end
     end
 
-  it "tests linear interpolation for N-dimensional y on another axis" do
-   f = Interpolation::OneDimensional.new(@x, @nd, {kind: :linear, axis: 1, 
-    sorted: true, precision: 3})
-   
-   expect(f.interpolate(3.5))              .to eq 37.342
+    context "#interp"
+  end
+
+  context :slinear do
+    
+  end
+
+  context :quadratic do
+    
+  end
+
+  context :cubic do
+    context "#interpolation" do
+      it "correctly interpolates for single axis co-ordinates" do
+        f = Interpolation::OneDimensional.new(@x, @y, type: :cubic, sorted: true)
+
+        expect(f.interpolate(2.5)).to eq(12.287)
+      end
+
+      it "interpolates for multiple points" do
+        f = Interpolation::OneDimensional.new(@x, @y, type: :cubic, sorted: true)
+        
+        expect(f.interpolate([2.5,3.5,4,6.5])).to eq([12.287, 32.577, 54.598, 688.288])
+      end
+
+      it "interpolates over all axes" do
+        f = Interpolation::OneDimensional.new(@x, @nd, type: :cubic, sorted: true, axis: :all)
 
-   expect(f.interpolate([2.5,6.7,0.3,8.6])).to eq [13.737, 888.672, 
-    1.515, 6054.234]
+        expect(f.interpolate(2.5)).to eq([12.287, 12.287, 12.287])
 
-   # expect(f.interpolate(NMatrix.new([4,1], [2.5,6.7,0.3,8.6]))).to eq NMatrix.new(
-   #  [4], [13.737, 888.672, 1.515, 6054.234])
+        expect(f.interpolate([2.5,3.5,4,6.5])). to eq([
+          [12.287, 12.287, 12.287],
+          [32.577, 32.577, 32.577], 
+          [54.598, 54.598, 54.598], 
+          [688.288, 688.288, 688.288]      
+        ]
+          )
+      end
+
+      it "interpolates only on the specified axis" do
+        f = Interpolation::OneDimensional.new(@x, @nd, type: :cubic, sorted: true, axis: 1)
+
+        expect(f.interpolate([2.5,3.5,4,6.5])).to eq([12.287, 32.577, 54.598, 688.288])
+      end
+    end
+
+    context "#interp" do
+      # TODO
+    end
   end
 end

data/spec/lib/2d_interpolation_spec.rb

@@ -0,0 +1,17 @@
+#--
+# = Interpolation 
+# Copyright (c) 2014, Sameer Deshmukh
+# All rights reserved.
+#   
+# Interpolation is a library for executing various interpolation 
+# functions in Ruby.
+# 
+# == spec/lib/2d_interpolation_spec.rb
+#
+# Tests for 2D interpolation.
+#++
+
+
+# describe Interpolation::TwoDimensional do
+  
+# end

data/spec/spec_helper.rb

@@ -1 +1,15 @@
+#--
+# = Interpolation 
+# Copyright (c) 2014, Sameer Deshmukh
+# All rights reserved.
+#   
+# Interpolation is a library for executing various interpolation 
+# functions in Ruby.
+# 
+# == spec/lib/1d_interpolation_spec.rb
+#
+# Tests for 1D interpolation.
+#++
+
+require 'matrix'
 require 'interpolation'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: interpolation
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Sameer Deshmukh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-08 00:00:00.000000000 Z
+date: 2014-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: nmatrix
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0.rc5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0.rc5
 description: Interpolation is a library for executing various interpolation functions
   in Ruby.
 email:
@@ -60,6 +46,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
 - ".rspec"
 - Gemfile
 - Gemfile.lock
@@ -70,8 +57,10 @@ files:
 - lib/interpolation.rb
 - lib/interpolation/base.rb
 - lib/interpolation/one_dimensional.rb
+- lib/monkeys.rb
 - lib/version.rb
 - spec/lib/1d_interpolation_spec.rb
+- spec/lib/2d_interpolation_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/v0dro/interpolation
 licenses:
@@ -98,3 +87,4 @@ signing_key:
 specification_version: 4
 summary: Interpolation routines in ruby.
 test_files: []
+has_rdoc: