savgol 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74cb6ba4eb41d56918d8e0994ecab490234bae85
-  data.tar.gz: 60e5ce50c918ac33ccf028a9e26773d06d59e7af
+  metadata.gz: bc7a6227404449143b6b264e85308bda89e5e2fa
+  data.tar.gz: 5e4089173d7d618e2bfe372a5758e78c6be22f36
 SHA512:
-  metadata.gz: 9698cb0c54a48b474f27badfa100b65ca92857829f59ed38ed304c5e9ed4428e28dbf260c6829731c5dbef197279d4796212d0ce9ece1252cbaa809a1fb0730e
-  data.tar.gz: cabf344682dbe30bd2d1beb1209dbdbf7530fcadfd70079fcd5edb967fcbd41bce049235c7d2f9482e10d007bd435f3afe2f387b5390163940a97cfe748c8850
+  metadata.gz: 6552c4e22998e3f8fb8b594f89684c42fe296496e1481b7f03aef6d43d68032ba23a8341a8288e2695b73b7e5527fc382f92dba9a02ff84764395949735c1836
+  data.tar.gz: dab124a5685cd5c3215d9b3ab628d626ec44590e883c1d340d4bbcad278d7a74f426520abdd19a8cbc16ee2dddd652014ecc1001a6ff7dcf9279c65ce91ce763

data/README.md

@@ -2,17 +2,48 @@
 
 Provides implementations of Savitzky-Golay smoothing (filtering).
 
-The gem is based on the [scipy implementation](http://www.scipy.org/Cookbook/SavitzkyGolay).  A good explanation of the process may be found [here on stackexchange](http://dsp.stackexchange.com/a/9494).
+The gem is based on the [scipy implementation](http://www.scipy.org/Cookbook/SavitzkyGolay) (gives exactly the same result).  A good explanation of the process may be found [here on stackexchange](http://dsp.stackexchange.com/a/9494).
 
 # Examples
 
-## Array implementation
+## Evenly spaced data
+
+### Array implementation (object oriented)
 
     require 'savgol/array'
     data = [1, 2, 3, 4, 3.5, 5, 3, 2.2, 3, 0, -1, 2, 0, -2, -5, -8, -7, -2, 0, 1, 1]
     # window size = 5, polynomial order = 3
     data.savgol(5,3)
 
+### Module implementation
+
+    require 'savgol'
+    data = [1, 2, 3, 4, 3.5, 5, 3, 2.2, 3, 0, -1, 2, 0, -2, -5, -8, -7, -2, 0, 1, 1]
+    # window size = 5, polynomial order = 3
+    Savgol.savgol(data, 5,3)
+
+## Uneven data
+
+The speed gain of the Savitzky-Golay filter is lost when interpolating
+unevenly spaced data and devolves into simple polynomial linear regression [At
+least I believe they are equivalent in complexity since both require a matrix
+pseudo-inverse calculation as the most complex operation].  Even though it may
+be much slower, a filter that handles unevenly spaced data may be useful in
+some cases.
+
+    require 'savgol'
+    xvals = %w(-1 0 2 3 4 7 8 10 11 12 13 14 17 18).map &:to_f
+    yvals = %w(-2 1 0 1 1 3 4 7  8  9  7  4  1   2).map {|v| v.to_f + 30 }
+
+### Interpolate at the given x-values
+
+    Savgol.savgol_uneven(xvals, yvals, 5, 2)
+
+### Interpolate at a new set of x values
+
+    new_xvals = xvals.map {|v| v + 0.5 }
+    Savgol.savgol_uneven(xvals, yvals, 5, 2, new_xvals: new_xvals)
+
 # Installation
     
     gem install savgol

data/lib/savgol.rb

@@ -1,13 +1,176 @@
 require 'savgol/version'
-require 'savgol/array'
+require 'matrix'
 
-module Savgol
+class NilEnumerator < Enumerator
+  def initialize(enum)
+    @enum = enum
+  end
+ 
+  def next
+    begin
+      @enum.next
+    rescue StopIteration
+      nil
+    end
+  end
 end
+ 
+module Savgol
+  class << self
+    # Does simple least squares to fit a polynomial based on the given x
+    # values.  The major speed-boost of doing savgol is lost for uneven time points.
+    # TODO: implement for different derivatives; implement with a window that
+    # is of fixed size (not based on the number of points)
+    def savgol_uneven(xvals, yvals, window_points=11, order=4, check_args: false, new_xvals: nil)
+      sg_check_arguments(window_points, order) if check_args
+
+      half_window = (window_points -1) / 2
+      yvals_padded = sg_pad_ends(yvals, half_window)
+      xvals_padded = sg_pad_xvals(xvals, half_window)
+      xvals_size = xvals.size
+
+      if new_xvals
+        nearest_xval_indices = sg_nearest_index(xvals, new_xvals)
+        new_xvals.zip(nearest_xval_indices).map do |new_xval, index|
+          sg_regress_and_find(
+            xvals_padded[index,window_points],  
+            yvals_padded[index,window_points],
+            order,
+            new_xval
+          )
+        end
+      else
+        xs_iter = xvals_padded.each_cons(window_points)
+        yvals_padded.each_cons(window_points).map do |ys|
+          xs = xs_iter.next
+          sg_regress_and_find(xs, ys, order, xs[half_window])
+        end
+      end
+    end
+
+    # returns the nearest index in original_vals for each value in new_vals
+    # (assumes both are sorted arrays). complexity: O(n + m)
+    def sg_nearest_index(original_vals, new_vals)
+      newval_iter = NilEnumerator.new(new_vals.each)
+      indices = []
+
+      index_iter = NilEnumerator.new((0...original_vals.size).each)
+      index = index_iter.next
+      newval=newval_iter.next
+      last_index = original_vals.size-1
+
+      until newval >= original_vals[index]
+        indices << index
+        break unless newval = newval_iter.next
+      end
+
+      loop do
+        break unless newval
+
+        if index.nil?
+          indices << last_index 
+        else
+          until newval <= original_vals[index]
+            index = index_iter.next
+            if !index
+              indices << last_index
+              break
+            end
+          end
+
+          if index
+            if newval < original_vals[index]
+              indices << ((newval - original_vals[index-1]) <= (original_vals[index] - newval) ? index-1 : index)
+            else
+              indices << index
+            end
+          end
+        end
+        newval = newval_iter.next
+      end
+
+      indices
+    end
 
-# ar = [1, 2, 3, 4, 3.5, 5, 3, 2.2, 3, 0, -1, 2, 0, -2, -5, -8, -7, -2, 0, 1, 1]
-# numpy_savgol_output = [1.0, 2.0, 3.12857143, 3.57142857, 4.27142857, 4.12571429, 3.36857143, 2.69714286, 2.04, 0.32571429, -0.05714286, 0.8, 0.51428571, -2.17142857, -5.25714286, -7.65714286, -6.4, -2.77142857, 0.17142857, 0.91428571, 1.0]
-# sg = ar.savgol(5,3)
-# 
-# sg.zip(numpy_savgol_output) do |sgv, numpy_sgv|
-#   p "#{sgv} vs #{numpy_sgv} diff #{(sgv - numpy_sgv).abs.round(8)}"
-# end
+    def sg_regress_and_find(xdata, ydata, order, xval)
+      xdata_matrix = xdata.map { |xi| (0..order).map { |pow| (xi**pow).to_f } }
+      mx = Matrix[*xdata_matrix]
+      my = Matrix.column_vector(ydata)
+      ((mx.t * mx).inv * mx.t * my).transpose.to_a[0].
+        zip((0..order).to_a).
+        map {|coeff, pow| coeff * (xval**pow) }.
+        reduce(:+)
+    end
+
+    def savgol(array, window_points=11, order=4, deriv: 0, check_args: false)
+      sg_check_arguments(window_points, order) if check_args
+      half_window = (window_points -1) / 2
+      weights = sg_weights(half_window, order, deriv)
+      padded_array = sg_pad_ends(array, half_window)
+      sg_convolve(padded_array, weights)
+    end
+
+    def sg_check_arguments(window_points, order)
+      if !window_points.is_a?(Integer) || window_points.abs != window_points || window_points % 2 != 1 || window_points < 1
+        raise ArgumentError, "window_points size must be a positive odd integer" 
+      end
+      if !order.is_a?(Integer) || order < 0
+        raise ArgumentError, "order must be an integer >= 0"
+      end
+      if window_points < order + 2
+        raise ArgumentError, "window_points is too small for the polynomials order"
+      end
+    end
+
+    def sg_convolve(data, weights, mode=:valid)
+      data.each_cons(weights.size).map do |ar|
+        ar.zip(weights).map {|pair| pair[0] * pair[1] }.reduce(:+)
+      end
+    end
+
+    # pads the ends with the reverse, geometric inverse sequence
+    def sg_pad_ends(array, half_window)
+      start = array[1..half_window]
+      start.reverse!
+      start.map! {|v| array[0] - (v - array[0]).abs }
+
+      fin = array[(-half_window-1)...-1]
+      fin.reverse!
+      fin.map! {|v| array[-1] + (v - array[-1]).abs }
+      start.push(*array, *fin)
+    end
+
+    # pads the ends of x vals
+    def sg_pad_xvals(array, half_window)
+      deltas = array[0..half_window].each_cons(2).map {|a,b| b-a }
+      start = array[0]
+      prevals = deltas.map do |delta| 
+        newval = start - delta
+        start = newval
+        newval
+      end
+      prevals.reverse!
+
+      deltas = array[(-half_window-1)..-1].each_cons(2).map {|a,b| b-a }
+      start = array[-1]
+      postvals = deltas.reverse.map do |delta| 
+        newval = start + delta
+        start = newval
+        newval
+      end
+
+      prevals.push(*array, *postvals)
+    end
+
+    # returns an object that will convolve with the padded array
+    def sg_weights(half_window, order, deriv=0)
+      # byebug
+      mat = Matrix[ *(-half_window..half_window).map {|k| (0..order).map {|i| k**i }} ]
+      # Moore-Penrose psuedo-inverse without SVD (not so precize)
+      # A' = (A.t * A)^-1 * A.t
+      pinv_matrix = Matrix[*(mat.transpose*mat).to_a].inverse * Matrix[*mat.to_a].transpose
+      pinv = Matrix[*pinv_matrix.to_a]
+      pinv.row(deriv).to_a
+    end
+  end
+end

data/lib/savgol/array.rb

@@ -1,57 +1,8 @@
-require "matrix"
-
-module Savgol
-	
-	def savgol(window_size, order, deriv=0, check_args=false)
-		  
-		# check arguments
-		if !window_size.is_a?(Integer) || window_size.abs != window_size || window_size % 2 != 1 || window_size < 1
-			raise ArgumentError, "window_size size must be a positive odd integer" 
-		end
-		if !order.is_a?(Integer) || order < 0
-			raise ArgumentError, "order must be an integer >= 0"
-		end
-		if window_size < order + 2
-			raise ArgumentError, "window_size is too small for the polynomials order"
-		end
-	  
-		half_window = (window_size -1) / 2
-		weights = sg_weights(half_window, order, deriv)
-		ar = sg_pad_ends(half_window)
-		sg_convolve(ar, weights)
-	end
-
-	def sg_convolve(data, weights, mode=:valid)
-		data.each_cons(weights.size).map do |ar|
-			ar.zip(weights).map {|pair| pair[0] * pair[1] }.reduce(:+)
-		end
-	end
-
-	# pads the ends with the reverse, geometric inverse sequence
-	def sg_pad_ends(half_window)
-		start = self[1..half_window]
-		start.reverse!
-		start.map! {|v| self[0] - (v - self[0]).abs }
-
-		fin = self[(-half_window-1)...-1]
-		fin.reverse!
-		fin.map! {|v| self[-1] + (v - self[-1]).abs }
-		start.push(*self, *fin)
-	end
-
-	# returns an object that will convolve with the padded array
-	def sg_weights(half_window, order, deriv=0)
-		# byebug
-		mat = Matrix[ *(-half_window..half_window).map {|k| (0..order).map {|i| k**i }} ]
-		# Moore-Penrose psuedo-inverse without SVD (not so precize)
-		# A' = (A.t * A)^-1 * A.t
-		pinv_matrix = Matrix[*(mat.transpose*mat).to_a].inverse * Matrix[*mat.to_a].transpose
-		pinv = Matrix[*pinv_matrix.to_a]
-		pinv.row(deriv).to_a
-	end
-
-end
+require 'savgol'
 
 class Array
-	include Savgol
+  # see Savgol#savgol
+	def savgol(*args)
+    Savgol.savgol(self, *args)
+  end
 end

data/lib/savgol/version.rb

@@ -1,3 +1,3 @@
 module Savgol
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/savgol.gemspec

@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
     ["rspec", "~> 2.14.1"], 
     ["rdoc", "~> 4.1.0"], 
     ["simplecov", "~> 0.8.2"],
+    ["gnuplot"],
   ].each do |args|
     spec.add_development_dependency(*args)
   end

data/spec/savgol_shared_example.rb

@@ -5,16 +5,9 @@ shared_examples "a savgol smoother" do
     object
   end
 
-  it 'pads with the reverse geometrically inverted sequence' do
-    expect(smoother.sg_pad_ends(2)).to eq [-1, 0, 1, 2, 3, 4, -7, -2, 0, 1, 1, 1, 2]
-    expect(smoother.sg_pad_ends(3)).to eq [-2, -1, 0, 1, 2, 3, 4, -7, -2, 0, 1, 1, 1, 2, 4]
-  end
-
   describe 'smoothing a signal' do
     let(:smoother) do
-      object = described_class[1, 2, 3, 4, 3.5, 5, 3, 2.2, 3, 0, -1, 2, 0, -2, -5, -8, -7, -2, 0, 1, 1]
-      object.extend(Savgol)
-      object
+      described_class[1, 2, 3, 4, 3.5, 5, 3, 2.2, 3, 0, -1, 2, 0, -2, -5, -8, -7, -2, 0, 1, 1]
     end
 
     it "works for the simple case" do

data/spec/savgol_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Savgol do
+  describe 'padding' do
+    let(:array) { [1, 2, 3, 4, -7, -2, 0, 1, 1] }
+    it 'pads with the reverse geometrically inverted sequence' do
+      expect(Savgol.sg_pad_ends(array, 2)).to eq [-1, 0, 1, 2, 3, 4, -7, -2, 0, 1, 1, 1, 2]
+      expect(Savgol.sg_pad_ends(array, 3)).to eq [-2, -1, 0, 1, 2, 3, 4, -7, -2, 0, 1, 1, 1, 2, 4]
+    end
+
+    it 'pads unevenly spaced x vals' do
+      ar = %w(-1 0 2 3 4 7 8 10 11 12 13 14 17 18).map &:to_f
+      expect(Savgol.sg_pad_xvals(ar, 2)).to eq %w(-4 -2 -1 0 2 3 4 7 8 10 11 12 13 14 17 18 19 22]).map(&:to_f)
+    end
+  end
+
+  describe 'finding nearest index' do
+    let(:original) { [0,1,2,3,4] }
+
+    it 'finds nearest index to the left' do
+      newvals = [-2, -1]
+      expect(Savgol.sg_nearest_index(original, newvals)).to eq([0,0])
+    end
+
+    it 'finds nearest indices in the middle' do
+      newvals = [1,1.4,1.5,1.6,2,2.1]
+      expect(Savgol.sg_nearest_index(original, newvals)).to eq([1,1,1,2,2,2])
+    end
+    
+    it 'finds nearest index to the right' do
+      newvals = [5,6]
+      expect(Savgol.sg_nearest_index(original, newvals)).to eq([4,4])
+    end
+
+    it 'efficiently finds the nearest index' do
+      newvals = [-2,-1,1,2.4,2.5,4,4.5,5]
+      expect(Savgol.sg_nearest_index(original, newvals)).to eq([0,0,1,2,2,4,4,4])
+    end
+  end
+
+  describe 'smoothing unevenly spaced data' do
+    xvals = %w(-1 0 2 3 4 7 8 10 11 12 13 14 17 18).map &:to_f
+    new_xvals = xvals.map {|v| v + 0.5 }
+    yvals = %w(-2 1 0 1 1 3 4 7  8  9  7  4  1   2).map {|v| v.to_f + 30 }
+
+    yvals_on = Savgol.savgol_uneven(xvals, yvals, 5, 2)
+
+    yvals_off = Savgol.savgol_uneven(xvals, yvals, 5, 2, new_xvals: new_xvals)
+
+    yvals_pretend_even = Savgol.savgol(yvals, 5, 2)
+
+    if false
+      require 'gnuplot'
+      Gnuplot.open do |gp|
+        Gnuplot::Plot.new(gp) do |plot|
+
+          plot.data << Gnuplot::DataSet.new([new_xvals, yvals_off]) do |ds|
+            ds.title = "x interpolated"
+            ds.with = "linespoints"
+          end
+
+          plot.data << Gnuplot::DataSet.new([xvals, yvals_pretend_even]) do |ds|
+            ds.title = "pretend evenly spaced"
+            ds.with = "linespoints"
+          end
+
+          plot.data << Gnuplot::DataSet.new([xvals, yvals_on]) do |ds|
+            ds.title = "smoothed"
+            ds.with = "linespoints"
+          end
+
+          plot.data << Gnuplot::DataSet.new([xvals, yvals]) do |ds|
+            ds.title = "original"
+            ds.with = "points"
+          end
+
+        end
+      end
+    end
+
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: savgol
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - John T. Prince
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-27 00:00:00.000000000 Z
+date: 2014-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,6 +81,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: gnuplot
+  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'
 description: Extends Array class with method which calculates applies Savitzky-Golay
   filter used for smoothing the data
 email:
@@ -102,6 +116,7 @@ files:
 - savgol.gemspec
 - spec/savgol/array_spec.rb
 - spec/savgol_shared_example.rb
+- spec/savgol_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/princelab/savgol
 licenses:
@@ -130,4 +145,5 @@ summary: performs Savitzky-Golay smoothing
 test_files:
 - spec/savgol/array_spec.rb
 - spec/savgol_shared_example.rb
+- spec/savgol_spec.rb
 - spec/spec_helper.rb