spliner 1.0.5 → 1.0.6

data/.gitignore

@@ -1,2 +1,3 @@
 *.gem
 Gemfile.lock
+.idea

data/.travis.yml

@@ -1,4 +1,5 @@
 rvm:
+  - 2.0.0
   - 1.9.2
   - 1.9.3
   - jruby

data/lib/spliner.rb

@@ -1,5 +1,5 @@
 require 'spliner/spliner'
 
 module Spliner
-  VERSION = '1.0.5'
+  VERSION = '1.0.6'
 end

data/lib/spliner/spliner.rb

@@ -170,10 +170,10 @@ module Spliner
            end
 
       get_func = lambda do |v|
-        i = @sections.find_index {|section| section.range.member? v }
+        i = @sections.find_index {|section| section.range.cover? v }
         if i
           @sections[i].get v
-        elsif range.member? v
+        elsif range.cover? v
           extrapolate(v)
         else
           nil

data/lib/spliner/spliner_section.rb

@@ -24,10 +24,10 @@ module Spliner
 
     def calculate_a_k
       if @x.size > 1
-        inv_diff = @x.each_cons(2).map {|x1, x2| 1 / (x2 - x1) }
+        inv_diff = @x.each_cons(2).map {|x1, x2| 1.0 / (x2 - x1) }
         a_diag = 2.0 * Matrix::diagonal(*vector_helper(inv_diff))
         a_non_diag = Matrix::build(@x.size) do |row, col|
-          if row == col+ 1
+          if row == col + 1
             inv_diff[col]
           elsif col == row + 1
             inv_diff[row]
@@ -41,11 +41,16 @@ module Spliner
         tmp = @x.zip(@y).each_cons(2).map do |p1, p2|
           x1, y1 = p1
           x2, y2 = p2
-          3.0 * (y2 - y1) / (x2 - x1) ** 2.0
+          delta_x = (x2 - x1)
+          3.0 * (y2 - y1) / (delta_x * delta_x)
         end
         b = vector_helper(tmp)
 
-        @k = a.inv * b
+        if RUBY_VERSION < "1.9.3"
+          @k = a.inv * b
+        else
+          @k = a.lup_decomposition.solve b
+        end
       else
         @k = Vector[0.0]
       end
@@ -54,14 +59,19 @@ module Spliner
 
     # returns an interpolated value
     def get(v)
-      i = @x_pairs.find_index {|pair| pair.member? v }
+      i = @x_pairs.find_index {|pair| pair.cover? v }
       if i
-        dx = @x[i + 1] - @x[i]
-        dy = @y[i + 1] - @y[i]
-        t = (v - @x[i]) / dx
-        a = @k[i] * dx - dy
-        b = -(@k[i + 1] * dx - dy)
-        (1 - t) * @y[i] + t * @y[i + 1] + t * (1 - t) * (a * (1 - t) + b * t)
+        x_pair = @x_pairs[i]
+        x_min = x_pair.min
+        dx = x_pair.max - x_min
+        y_max = @y[i + 1]
+        y_min = @y[i]
+        dy = y_max - y_min
+        t = (v - x_min) / dx
+        a =      @k[i] * dx - dy
+        b = -@k[i + 1] * dx + dy
+        one_minus_t = 1 - t
+        t * y_max + one_minus_t * ( y_min + t * ( a * one_minus_t + b * t ) )
       elsif @x.size == 1 && @x.first == v
         @y.first
       else

data/spec/spliner_spec.rb

@@ -6,6 +6,17 @@ describe Spliner::Spliner do
   DATASET_Y = [0.0, 1.0, 0.5]
   KEYS_0_100 = {0.0 => 0.0, 100.0 => 100.0}
 
+  before(:all) do
+    epsilon = nil
+    e = 1
+    while e + 1 > 1
+      epsilon = e
+      e *= 0.5
+    end
+    
+    @two_epsilon = 2 * epsilon
+  end
+
 
   it 'should not accept x values that are not increasing' do
     expect(lambda { Spliner::Spliner.new [0.0, -1.0], [0.0, 1.0] }).to raise_exception
@@ -13,33 +24,33 @@ describe Spliner::Spliner do
 
   it 'should support key points with a single value' do
     s1 = Spliner::Spliner.new Hash[0.0, 0.0]
-    expect(s1.get 0.0).to be_within(0.0001).of(0.0)
+    expect(s1.get 0.0).to be_within(@two_epsilon).of(0.0)
     expect(s1.get 1.5).to be_nil
 
     s2 = Spliner::Spliner.new Hash[0.0, 0.0], :extrapolate => -1..1
-    expect(s2.get 0.0).to be_within(0.0001).of(0.0)
-    expect(s2.get 0.5).to be_within(0.0001).of(0.0)
+    expect(s2.get 0.0).to be_within(@two_epsilon).of(0.0)
+    expect(s2.get 0.5).to be_within(@two_epsilon).of(0.0)
   end
 
   it 'supports the Hash initializer' do
     s1 = Spliner::Spliner.new Hash[0.0, 0.0, 1.0, 1.0]
-    expect(s1[0.5]).to be_within(0.0001).of(0.5)
+    expect(s1[0.5]).to be_within(@two_epsilon).of(0.5)
 
     s2 = Spliner::Spliner.new Hash[0.0, 0.0, 1.0, 1.0], :extrapolate => '100%'
-    expect(s2[0.5]).to be_within(0.0001).of(0.5)
-    expect(s2.range.first).to be_within(0.0001).of(-1.0)
+    expect(s2[0.5]).to be_within(@two_epsilon).of(0.5)
+    expect(s2.range.first).to be_within(@two_epsilon).of(-1.0)
   end
 
   it 'supports the x-y array/vector initializer' do
     s1 = Spliner::Spliner.new [0.0, 1.0], [0.0, 1.0]
-    expect(s1[0.5]).to be_within(0.0001).of(0.5)
+    expect(s1[0.5]).to be_within(@two_epsilon).of(0.5)
 
     s2= Spliner::Spliner.new [0.0, 1.0], [0.0, 1.0], :extrapolate => '100%'
-    expect(s2[0.5]).to be_within(0.0001).of(0.5)
-    expect(s2.range.first).to be_within(0.0001).of(-1.0)
+    expect(s2[0.5]).to be_within(@two_epsilon).of(0.5)
+    expect(s2.range.first).to be_within(@two_epsilon).of(-1.0)
 
     s3 = Spliner::Spliner.new Vector[0.0, 1.0], Vector[0.0, 1.0]
-    expect(s3[0.5]).to be_within(0.0001).of(0.5)
+    expect(s3[0.5]).to be_within(@two_epsilon).of(0.5)
   end
 
   it 'should return the data points themselves' do
@@ -57,62 +68,62 @@ describe Spliner::Spliner do
 
   it 'should generate a smooth curve (predefined points)' do
     s = Spliner::Spliner.new DATASET
-    expect(s.get(0.4)).to be_within(0.0001).of(0.5260)
-    expect(s.get(0.8)).to be_within(0.0001).of(0.9080)
-    expect(s.get(1.2)).to be_within(0.0001).of(1.0080)
-    expect(s.get(1.6)).to be_within(0.0001).of(0.8260)
+    expect(s.get(0.4)).to be_within(@two_epsilon).of(0.5260)
+    expect(s.get(0.8)).to be_within(@two_epsilon).of(0.9080)
+    expect(s.get(1.2)).to be_within(@two_epsilon).of(1.0080)
+    expect(s.get(1.6)).to be_within(@two_epsilon).of(0.8260)
   end
 
   it 'should perform linear interpolation in the case of two data points' do
     s = Spliner::Spliner.new({0 => 0, 10.0 => 100.0})
-    expect(s.get(3.0)).to be_within(0.0001).of(30.0)
+    expect(s.get(3.0)).to be_within(@two_epsilon).of(30.0)
   end
 
   it 'supports the [] operator (indexing like)' do
     s = Spliner::Spliner.new DATASET
     expect(s[-1]).to be_nil
-    expect(s[0]).to be_within(0.0001).of(0.0)
+    expect(s[0]).to be_within(@two_epsilon).of(0.0)
   end
 
   it 'performs :linear extrapolation outside the data range when such is given' do
     s = Spliner::Spliner.new KEYS_0_100, :extrapolate => -200..200
     expect(s.get -110).not_to be_nil
-    expect(s.get -150).to be_within(0.0001).of(-150)
-    expect(s.get 150).to be_within(0.0001).of(150)
+    expect(s.get -150).to be_within(1e-13).of(-150)
+    expect(s.get 150).to be_within(1e-13).of(150)
   end
 
   it 'performs :hold extrapolation' do
     s = Spliner::Spliner.new KEYS_0_100, :extrapolate => -200..200, :emethod => :hold
-    expect(s.get -150).to be_within(0.0001).of(0)
-    expect(s.get 150).to be_within(0.0001).of(100)
+    expect(s.get -150).to be_within(@two_epsilon).of(0)
+    expect(s.get 150).to be_within(@two_epsilon).of(100)
   end
 
   it 'supports data ranges given as a string like "10%"' do
     s1 = Spliner::Spliner.new KEYS_0_100, :extrapolate => '10%'
-    expect(s1.range.first).to be_within(0.0001).of(-10.0)
-    expect(s1.range.last).to be_within(0.0001).of(110.0)
+    expect(s1.range.first).to be_within(@two_epsilon).of(-10.0)
+    expect(s1.range.last).to be_within(@two_epsilon).of(110.0)
 
     s2 = Spliner::Spliner.new KEYS_0_100, :extrapolate => '10.0%'
-    expect(s2.range.first).to be_within(0.0001).of(-10.0)
-    expect(s2.range.last).to be_within(0.0001).of(110.0)
+    expect(s2.range.first).to be_within(@two_epsilon).of(-10.0)
+    expect(s2.range.last).to be_within(@two_epsilon).of(110.0)
 
     s3 = Spliner::Spliner.new KEYS_0_100, :extrapolate => '10 %'
-    expect(s3.range.first).to be_within(0.0001).of(-10.0)
-    expect(s3.range.last).to be_within(0.0001).of(110.0)
+    expect(s3.range.first).to be_within(@two_epsilon).of(-10.0)
+    expect(s3.range.last).to be_within(@two_epsilon).of(110.0)
 
     s4 = Spliner::Spliner.new KEYS_0_100, :extrapolate => 0.1
-    expect(s3.range.first).to be_within(0.0001).of(-10.0)
-    expect(s3.range.last).to be_within(0.0001).of(110.0)
+    expect(s3.range.first).to be_within(@two_epsilon).of(-10.0)
+    expect(s3.range.last).to be_within(@two_epsilon).of(110.0)
   end
 
   it 'splits data points with duplicate X values into separate sections' do
     s = Spliner::Spliner.new [0.0, 1.0, 1.0, 2.0, 2.0, 3.0], [0.0, 0.0, 1.0, 1.0, 2.0, 2.0], :extrapolate => 3.0..4.0
     expect(s.sections).to eq(3)
     expect(s[-1.0]).to be_nil
-    expect(s[0.5]).to be_within(0.0001).of(0.0)
-    expect(s[1.5]).to be_within(0.0001).of(1.0)
-    expect(s[2.5]).to be_within(0.0001).of(2.0)
-    expect(s[3.5]).to be_within(0.0001).of(2.0)
+    expect(s[0.5]).to be_within(@two_epsilon).of(0.0)
+    expect(s[1.5]).to be_within(@two_epsilon).of(1.0)
+    expect(s[2.5]).to be_within(@two_epsilon).of(2.0)
+    expect(s[3.5]).to be_within(@two_epsilon).of(2.0)
     expect(s[5.0]).to be_nil
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spliner
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-12 00:00:00.000000000 Z
+date: 2013-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -81,9 +81,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: spliner
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Cubic spline interpolation library
-test_files: []
-has_rdoc: 
+test_files:
+- spec/spliner_spec.rb