interpolation 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 736c1de695651f5d9b074dbc0e4dfe56614c3ad4
+  data.tar.gz: 4ce0806e958fbff6c78fbe94992f0f8259f46955
+SHA512:
+  metadata.gz: ce4fe2d42c2bf757b8cea3b647c754e7797878ad22c29fd1ae388b9b9a4a55d80f21015bb5f590b9dcd3fb70869e27d21f421ca529e4f2bfa5b378dfbe57440a
+  data.tar.gz: 9bc487d1338da2ecfd509028d9b9fdbc4962f2e54b525d821bd403c5b2af1009b3b423ab87f0cd20814d5b2d36cf3a83b5c2560927a0abef5b1fc4b89cbb6cb2

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    interpolation (0.0.1)
+      nmatrix (~> 0.1.0.rc5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    json (1.8.1)
+    nmatrix (0.1.0.rc5)
+      rdoc (~> 4.0, >= 4.0.1)
+    rake (10.3.2)
+    rdoc (4.1.1)
+      json (~> 1.4)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.1)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.0)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  interpolation!
+  rake
+  rspec

data/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2014, Sameer Deshmukh
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README.md

@@ -0,0 +1,4 @@
+interpolation
+=============
+
+Interpolation routines for ruby.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/interpolation.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require 'version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "interpolation"
+  gem.version       = Interpolation::VERSION
+  gem.summary       = "Interpolation routines in ruby."
+  gem.description   = "Interpolation is a library for executing various interpolation functions in Ruby."
+  gem.homepage      = 'https://github.com/v0dro/interpolation'
+  gem.authors       = ['Sameer Deshmukh'] 
+  gem.email         =  ['sameer.deshmukh93@gmail.com']
+  gem.license       = 'BSD 3-clause'
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+
+  gem.add_runtime_dependency 'nmatrix', '~> 0.1.0.rc5'
+end

data/lib/interpolation.rb

@@ -0,0 +1,5 @@
+require 'nmatrix'
+
+$:.unshift File.dirname(__FILE__)
+
+require 'interpolation/one_dimensional.rb'

data/lib/interpolation/base.rb

@@ -0,0 +1,64 @@
+#--
+# = Interpolation
+#   
+# Interpolation is a library for executing various interpolation 
+# functions in Ruby. Works with NMatrix.
+# 
+# == interpolation/base.rb
+#
+# Base class for all interpolation methods.
+#++
+
+module Interpolation
+  class Base
+    def initialize x, y, opts
+      @x, @y, @opts = x, y, opts
+
+      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)
+
+      @size = @x.size # considers size of @x only
+      @x    = @x.sort unless @opts[:sorted]
+    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 
+      # Returns the index of the value 'num' such that x[j] > num > x[j+1]
+      ascnd = (@x[-1] >= @x[0])
+
+      jl, jm, ju = 0, 0,@x.size-1
+
+      while ju - jl > 1
+        jm = (ju+jl)/2
+
+        if num >= @x[jm] == ascnd
+          jl = jm
+        else
+          ju = jm
+        end
+      end
+
+      if    num == @x[0]       then return 0
+      elsif num == @x[@size-1] then return @size-2
+      else                          return jl
+      end
+    end 
+
+    def invalid_axis?
+      @opts[:axis] and @opts[:axis] > @y.cols-1
+    end
+
+  end
+end

data/lib/interpolation/one_dimensional.rb

@@ -0,0 +1,141 @@
+$:.unshift File.dirname(__FILE__)
+
+#--
+# = Interpolation
+#   
+# Interpolation is a library for executing various interpolation 
+# functions in Ruby. Works with NMatrix.
+# 
+# == interpolation/one_dimensional.rb
+#
+# Methods for performing one dimensional interpolation.
+#++
+
+require 'base.rb'
+
+module Interpolation
+
+  # Implements one dimensional interpolation routines.
+  # 
+  # ==== Usage
+  # 
+  # x = NMatrix.seq [10]
+  # y = x.exp
+  # 
+  # f = NMatrix::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
+
+    # Constructor for all One Dimensional interpolation operations.
+    # 
+    # The function values to be supplied to this class are of the form y = f(x). 
+    # 
+    # Henceforth, y will be referred to as ordinate and x as absicca. If absicca 
+    # and ordinate arrays are not of the same length, then the effective size used 
+    # for interpolation will be MIN(x.size, y.size).
+    # 
+    # ==== Arguments
+    # 
+    # * +x+ -    The collection of absiccas. Must be a 1 D NMatrix or ruby Array.
+    # 
+    # * +y+ -    The collection of ordinates corresponding to the absicca. 'y' can 
+    #            either be a 1D NMatrix or Array OR a 2D NMatrix. In case y contains 
+    #            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.
+    # 
+    # ==== 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. 
+    # 
+    # * +: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.
+    # 
+    # * +:precision+ - Specifies the precision of the interpolated values returned. Defaults
+    #             to 3.
+    # 
+    def initialize x, y, opts={}
+      super(x,y,opts)
+    end
+
+    # Performs the actual interpolation on the value passed as an argument. Kind of 
+    # interpolation performed is determined according to what is specified in the 
+    # constructor.
+    # 
+    # ==== Arguments
+    # 
+    # * +interpolant+ - The value for which the interpolation is to be performed. Can
+    #                   either be a Numeric, Array of Numerics or NMatrix. If multidimensional
+    #                   NMatrix is supplied then will flatten it and interpolate over
+    #                   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]
+      when :linear
+        for_each (interpolant) { |x| linear_interpolation(x)  }
+      else
+        raise(ArgumentError, "1 D interpolation of kind #{@opts[:kind]} \
+         not supported")
+      end
+
+      # return result.to_nm(result.size) if interpolant.is_a?(NMatrix)
+
+      result
+    end
+
+   private
+
+    def for_each interpolant
+      result = []
+
+      if interpolant.kind_of? Numeric
+        return yield interpolant
+      else
+        interpolant.each { |x| result << yield(x) }
+      end
+
+      result
+    end
+
+    def linear_interpolation interpolant
+      # TODO : Make this more efficient by using hunt/locate from NR
+      index  = locate(interpolant)
+      same   = @x[index] == @x[index+1]
+      result = []              
+
+      if (@y.respond_to?(:vector?) and @y.vector?) or
+        @y.instance_of?(Array)
+
+        return @y[index] if same
+        return _lin_interpolator @y, index, interpolant
+      elsif @opts[:axis]
+
+        return @y.column(@opts[:axis])[index] if same
+        return _lin_interpolator @y.column(@opts[:axis]), index, interpolant
+      else
+        @y.each_column do |c|
+          result << (same ? c[index] : _lin_interpolator(c, index, interpolant))
+        end
+      end
+
+      result
+    end
+
+    def _lin_interpolator y, index, interpolant
+      (y[index] + 
+      ((interpolant - @x[index]) / (@x[index + 1] - @x[index])) * 
+       (y[index + 1] - y[index])).round(@opts[:precision])
+    end
+  end
+end

data/lib/version.rb

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

data/spec/lib/1d_interpolation_spec.rb

@@ -0,0 +1,78 @@
+#--
+# = Interpolation
+#   
+# Interpolation is a library for executing various interpolation 
+# functions in Ruby. Works with NMatrix.
+# 
+# == spec/lib/1d_interpolation_spec.rb
+#
+# Tests for 1D interpolation.
+#++
+
+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 }
+  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})
+
+    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})
+
+    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(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
+
+    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(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 "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
+
+   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

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'interpolation'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: interpolation
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sameer Deshmukh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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:
+- sameer.deshmukh93@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- interpolation.gemspec
+- lib/interpolation.rb
+- lib/interpolation/base.rb
+- lib/interpolation/one_dimensional.rb
+- lib/version.rb
+- spec/lib/1d_interpolation_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/v0dro/interpolation
+licenses:
+- BSD 3-clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Interpolation routines in ruby.
+test_files: []