bio-statsample-timeseries 0.1.1

data/lib/bio-statsample-timeseries/arima.rb

@@ -0,0 +1,124 @@
+#require 'debugger'
+module Statsample
+  module ARIMA
+    class ARIMA < Statsample::Vector
+      include Statsample::TimeSeries
+
+      def arima(ds, p, i, q)
+        #prototype
+        if q.zero?
+          self.ar(p)
+        elsif p.zero?
+          self.ma(p)
+        end
+      end
+
+      def ar(p)
+        #AutoRegressive part of model
+        #http://en.wikipedia.org/wiki/Autoregressive_model#Definition
+        #For finding parameters(to fit), we will use either Yule-walker
+        #or Burg's algorithm(more efficient)
+      end
+
+      def yule_walker()
+        #To be implemented
+      end
+
+      def create_vector(arr)
+        Statsample::Vector.new(arr, :scale)
+      end
+
+      #tentative AR(p) simulator
+      def ar_sim(n, phi, sigma)
+        #using random number generator for inclusion of white noise
+        err_nor = Distribution::Normal.rng(0, sigma)
+        #creating buffer with 10 random values
+        buffer = Array.new(10, err_nor.call())
+
+        x = buffer + Array.new(n, 0)
+
+        #For now "phi" are the known model parameters
+        #later we will obtain it by Yule-walker/Burg
+
+        #instead of starting from 0, start from 11
+        #and later take away buffer values for failsafe
+        11.upto(n+11) do |i|
+          if i <= phi.size
+            #dependent on previous accumulation of x
+            backshifts = create_vector(x[0...i].reverse)
+          else
+            #dependent on number of phi size/order
+            backshifts = create_vector(x[(i - phi.size)...i].reverse)
+          end
+          parameters = create_vector(phi[0...backshifts.size])
+
+          summation = (backshifts * parameters).inject(:+)
+          x[i] = summation + err_nor.call()
+        end
+        x - buffer
+      end
+
+      #moving average simulator
+      def ma_sim(n, theta, sigma)
+        #n is number of observations (eg: 1000)
+        #theta are the model parameters containting q values
+        #q is the order of MA
+        mean = theta.to_ts.mean()
+        whitenoise_gen = Distribution::Normal.rng(0, sigma)
+        x = Array.new(n, 0)
+        q = theta.size
+        noise_arr = (n+1).times.map { whitenoise_gen.call() }
+
+        1.upto(n) do |i|
+          #take care that noise vector doesn't try to index -ve value:
+          if i <= q
+            noises = create_vector(noise_arr[0..i].reverse)
+          else
+            noises = create_vector(noise_arr[(i-q)..i].reverse)
+          end
+          weights = create_vector([1] + theta[0...noises.size - 1])
+
+          summation = (weights * noises).inject(:+)
+          x[i] = mean + summation
+        end
+        x
+      end
+
+      #arma simulator
+      def arma_sim(n, p, q, sigma)
+        #represented by :
+        #http://upload.wikimedia.org/math/2/e/d/2ed0485927b4370ae288f1bc1fe2fc8b.png
+
+
+        whitenoise_gen = Distribution::Normal.rng(0, sigma)
+        noise_arr = (n+11).times.map { whitenoise_gen.call() }
+
+        buffer = Array.new(10, whitenoise_gen.call())
+        x = buffer + Array.new(n, 0)
+
+        11.upto(n+11) do |i|
+          if i <= p.size
+            backshifts = create_vector(x[0...i].reverse)
+          else
+            backshifts = create_vector(x[(i - p.size)...i].reverse)
+          end
+          parameters = create_vector(p[0...backshifts.size])
+
+          ar_summation = (backshifts * parameters).inject(:+)
+
+          if i <= q.size
+            noises = create_vector(noise_arr[0..i].reverse)
+          else
+            noises = create_vector(noise_arr[(i-q.size)..i].reverse)
+          end
+          weights = create_vector([1] + q[0...noises.size - 1])
+
+          ma_summation = (weights * noises).inject(:+)
+
+          x[i] = ar_summation + ma_summation
+        end
+        x - buffer
+      end
+    end
+  end
+end

data/lib/bio-statsample-timeseries/statsample-timeseries.rb

@@ -0,0 +1,2 @@
+
+

data/lib/bio-statsample-timeseries/timeseries.rb

@@ -0,0 +1,181 @@
+require 'bio-statsample-timeseries/timeseries/pacf'
+module Statsample::TimeSeriesShorthands
+  # Creates a new Statsample::TimeSeries object
+  # Argument should be equal to TimeSeries.new
+  def to_time_series(*args)
+    Statsample::TimeSeries::TimeSeries.new(self, :scale, *args)
+  end
+
+  alias :to_ts :to_time_series
+end
+
+class Array
+  include Statsample::TimeSeriesShorthands
+end
+
+module Statsample
+  module TimeSeries
+    # Collection of data indexed by time.
+    # The order goes from earliest to latest.
+    class TimeSeries < Statsample::Vector
+      include Statsample::TimeSeries::Pacf
+      # Calculates the autocorrelation coefficients of the series.
+      #
+      # The first element is always 1, since that is the correlation
+      # of the series with itself.
+      #
+      # Usage:
+      #
+      #  ts = (1..100).map { rand }.to_time_series
+      #
+      #  ts.acf   # => array with first 21 autocorrelations
+      #  ts.acf 3 # => array with first 3 autocorrelations
+      #
+      def acf max_lags = nil
+        max_lags ||= (10 * Math.log10(size)).to_i
+
+        (0..max_lags).map do |i|
+          if i == 0
+            1.0
+          else
+            m = self.mean
+
+            # can't use Pearson coefficient since the mean for the lagged series should
+            # be the same as the regular series
+            ((self - m) * (self.lag(i) - m)).sum / self.variance_sample / (self.size - 1)
+          end
+        end
+      end
+
+      def pacf(max_lags = nil, method = 'yw')
+        #parameters:
+        #max_lags => maximum number of lags for pcf
+        #method => for autocovariance in yule_walker:
+          #'yw' for 'yule-walker unbaised', 'mle' for biased maximum likelihood
+
+        max_lags ||= (10 * Math.log10(size)).to_i
+       Pacf::Pacf.pacf_yw(self, max_lags, method)
+      end
+
+      # Lags the series by k periods.
+      #
+      # The convention is to set the oldest observations (the first ones
+      # in the series) to nil so that the size of the lagged series is the
+      # same as the original.
+      #
+      # Usage:
+      #
+      #  ts = (1..10).map { rand }.to_time_series
+      #           # => [0.69, 0.23, 0.44, 0.71, ...]
+      #
+      #  ts.lag   # => [nil, 0.69, 0.23, 0.44, ...]
+      #  ts.lag 2 # => [nil, nil, 0.69, 0.23, ...]
+      #
+      def lag k = 1
+        return self if k == 0
+
+        dup.tap do |lagged|
+          (lagged.size - 1).downto k do |i|
+            lagged[i] = lagged[i - k]
+          end
+
+          (0...k).each do |i|
+            lagged[i] = nil
+          end
+          lagged.set_valid_data
+        end
+      end
+
+      # Performs a first difference of the series.
+      #
+      # The convention is to set the oldest observations (the first ones
+      # in the series) to nil so that the size of the diffed series is the
+      # same as the original.
+      #
+      # Usage:
+      #
+      #  ts = (1..10).map { rand }.to_ts
+      #            # => [0.69, 0.23, 0.44, 0.71, ...]
+      #
+      #  ts.diff   # => [nil, -0.46, 0.21, 0.27, ...]
+      #
+      def diff
+        self - self.lag
+      end
+
+      # Calculates a moving average of the series using the provided
+      # lookback argument. The lookback defaults to 10 periods.
+      #
+      # Usage:
+      #
+      #   ts = (1..100).map { rand }.to_ts
+      #            # => [0.69, 0.23, 0.44, 0.71, ...]
+      #
+      #   # first 9 observations are nil
+      #   ts.ma    # => [ ... nil, 0.484... , 0.445... , 0.513 ... , ... ]
+      def ma n = 10
+        return mean if n >= size
+
+        ([nil] * (n - 1) + (0..(size - n)).map do |i|
+          self[i...(i + n)].inject(&:+) / n
+        end).to_time_series
+      end
+
+      # Calculates an exponential moving average of the series using a
+      # specified parameter. If wilder is false (the default) then the EMA
+      # uses a smoothing value of 2 / (n + 1), if it is true then it uses the
+      # Welles Wilder smoother of 1 / n.
+      #
+      # Warning for EMA usage: EMAs are unstable for small series, as they
+      # use a lot more than n observations to calculate. The series is stable
+      # if the size of the series is >= 3.45 * (n + 1)
+      #
+      # Usage: 
+      #
+      #   ts = (1..100).map { rand }.to_ts
+      #            # => [0.69, 0.23, 0.44, 0.71, ...]
+      #
+      #   # first 9 observations are nil
+      #   ts.ema   # => [ ... nil, 0.509... , 0.433..., ... ]
+      def ema n = 10, wilder = false
+        smoother = wilder ? 1.0 / n : 2.0 / (n + 1)
+
+        # need to start everything from the first non-nil observation
+        start = self.data.index { |i| i != nil }
+
+        # first n - 1 observations are nil
+        base = [nil] * (start + n - 1)
+
+        # nth observation is just a moving average
+        base << self[start...(start + n)].inject(0.0) { |s, a| a.nil? ? s : s + a } / n
+
+        (start + n).upto size - 1 do |i|
+          base << self[i] * smoother + (1 - smoother) * base.last
+        end
+
+        base.to_time_series
+      end
+
+      # Calculates the MACD (moving average convergence-divergence) of the time
+      # series - this is a comparison of a fast EMA with a slow EMA.
+      def macd fast = 12, slow = 26, signal = 9
+        series = ema(fast) - ema(slow)
+        [series, series.ema(signal)]
+      end
+
+      # Borrow the operations from Vector, but convert to time series
+      def + series
+        super.to_a.to_ts
+      end
+
+      def - series
+        super.to_a.to_ts
+      end
+
+      def to_s
+        sprintf("Time Series(type:%s, n:%d)[%s]", @type.to_s, @data.size,
+                @data.collect{|d| d.nil? ? "nil":d}.join(","))
+      end
+    end
+  end
+end

data/lib/bio-statsample-timeseries/timeseries/pacf.rb

@@ -0,0 +1,100 @@
+module Statsample
+  module TimeSeries
+    module Pacf
+      class Pacf
+
+        def self.pacf_yw(timeseries, max_lags, method = 'yw')
+          #partial autocorrelation by yule walker equations.
+          #Inspiration: StatsModels
+          pacf = [1.0]
+          (1..max_lags).map do |i|
+            pacf << yule_walker(timeseries, i, method)[-1]
+          end
+          pacf
+        end
+
+        def self.yule_walker(ts, k = 1, method='yw')
+          #From the series, estimates AR(p)(autoregressive) parameter
+          #using Yule-Waler equation. See -
+          #http://en.wikipedia.org/wiki/Autoregressive_moving_average_model
+
+          #parameters:
+          #ts = series
+          #k = order, default = 1
+          #method = can be 'yw' or 'mle'. If 'yw' then it is unbiased, denominator
+          #is (n - k)
+
+          #returns:
+          #rho => autoregressive coefficients
+          ts = ts - ts.mean
+          n = ts.size
+          if method.downcase.eql? 'yw'
+            #unbiased => denominator = (n - k)
+            denom =->(k) { n - k }
+          else
+            #mle
+            #denominator => (n)
+            denom =->(k) { n }
+          end
+          r = Array.new(k + 1) { 0.0 }
+          r[0] = ts.map { |x| x ** 2 }.inject(:+).to_f / denom.call(0).to_f
+
+          1.upto(k) do |l|
+            r[l] = (ts[0...-l].zip(ts[l...ts.size])).map do |x|
+              x.inject(:*)
+            end.inject(:+).to_f / denom.call(l).to_f
+          end
+
+          r_R = toeplitz(r[0...-1])
+
+          mat = Matrix.columns(r_R).inverse()
+          solve_matrix(mat, r[1..r.size])
+        end
+
+        def self.toeplitz(arr)
+          #Generates Toeplitz matrix -
+          #http://en.wikipedia.org/wiki/Toeplitz_matrix
+          #Toeplitz matrix are equal when they are stored in row &
+          #column major
+          #=> arr = [0, 1, 2, 3]
+          #=> result:
+          #[[0, 1, 2, 3],
+          # [1, 0, 1, 2],
+          # [2, 1, 0, 1],
+          # [3, 2, 1, 0]]
+          eplitz_matrix = Array.new(arr.size) { Array.new(arr.size) }
+
+          0.upto(arr.size - 1) do |i|
+            j = 0
+            index = i
+            while i >= 0 do
+              eplitz_matrix[index][j] = arr[i]
+              j += 1
+              i -= 1
+            end
+            i = index + 1; k = 1
+            while i < arr.size do
+              eplitz_matrix[index][j] = arr[k]
+              i += 1; j += 1; k += 1
+            end
+          end
+          eplitz_matrix
+        end
+
+        def self.solve_matrix(matrix, out_vector)
+          solution_vector = Array.new(out_vector.size, 0)
+          matrix = matrix.to_a
+          k = 0
+          matrix.each do |row|
+            row.each_with_index do |element, i|
+              solution_vector[k] += element * 1.0 * out_vector[i]
+            end
+            k += 1
+          end
+          solution_vector
+        end
+
+      end
+    end
+  end
+end

data/test/fixtures/stock_data.csv

@@ -0,0 +1,500 @@
+17.66
+17.65
+17.68
+17.66
+17.68
+17.67
+17.68
+17.68
+17.67
+17.67
+17.68
+17.71
+17.74
+17.72
+17.73
+17.76
+17.74
+17.69
+17.69
+17.67
+17.66
+17.67
+17.69
+17.69
+17.68
+17.65
+17.65
+17.64
+17.63
+17.64
+17.67
+17.68
+17.7
+17.68
+17.69
+17.69
+17.72
+17.71
+17.71
+17.71
+17.69
+17.69
+17.71
+17.72
+17.71
+17.68
+17.68
+17.68
+17.69
+17.68
+17.68
+17.69
+17.67
+17.69
+17.71
+17.7
+17.7
+17.71
+17.73
+17.74
+17.74
+17.74
+17.76
+17.77
+17.55
+17.55
+17.5
+17.46
+17.49
+17.54
+17.51
+17.54
+17.57
+17.54
+17.52
+17.53
+17.56
+17.55
+17.55
+17.54
+17.55
+17.55
+17.55
+17.54
+17.52
+17.53
+17.51
+17.52
+17.5
+17.5
+17.5
+17.49
+17.46
+17.47
+17.48
+17.45
+17.41
+17.39
+17.38
+17.43
+17.44
+17.43
+17.43
+17.46
+17.46
+17.47
+17.47
+17.45
+17.48
+17.49
+17.5
+17.49
+17.48
+17.49
+17.47
+17.47
+17.44
+17.44
+17.43
+17.45
+17.42
+17.43
+17.43
+17.44
+17.44
+17.43
+17.41
+17.41
+17.38
+17.38
+17.37
+17.37
+17.37
+17.3
+17.28
+17.27
+17.19
+16.41
+16.44
+16.48
+16.53
+16.51
+16.57
+16.54
+16.59
+16.64
+16.6
+16.65
+16.69
+16.69
+16.68
+16.64
+16.65
+16.66
+16.64
+16.61
+16.65
+16.67
+16.66
+16.65
+16.61
+16.59
+16.57
+16.55
+16.55
+16.57
+16.54
+16.6
+16.62
+16.6
+16.59
+16.61
+16.66
+16.69
+16.67
+16.65
+16.66
+16.65
+16.65
+16.68
+16.68
+16.67
+16.64
+16.73
+16.76
+16.75
+16.79
+16.8
+16.77
+16.74
+16.76
+16.83
+16.84
+16.82
+16.89
+16.93
+16.94
+16.9
+16.92
+16.88
+16.85
+16.87
+16.8
+16.79
+16.85
+16.85
+16.8
+16.82
+16.85
+16.9
+16.86
+16.79
+16.75
+16.78
+17.06
+17.05
+17.04
+17.02
+17.01
+17.02
+17.05
+17.07
+17.08
+17.09
+17.1
+17.11
+17.09
+17.1
+17.1
+17.12
+17.17
+17.16
+17.17
+17.18
+17.18
+17.18
+17.17
+17.15
+17.14
+17.13
+17.14
+17.13
+17.12
+17.12
+17.09
+17.09
+17.11
+17.06
+17.07
+17.06
+17.07
+17.06
+17.09
+17.05
+17.04
+17.04
+16.99
+17
+17.03
+17
+16.97
+16.96
+16.98
+16.98
+16.98
+17.03
+17
+17
+17
+17.02
+17
+17.02
+17.01
+17.02
+17.03
+17.03
+17.01
+17.03
+17.03
+17.03
+17.01
+17.03
+17.05
+17.05
+17.08
+17.04
+17.01
+17.03
+17.02
+17.03
+17.04
+17.05
+17.37
+17.35
+17.34
+17.32
+17.29
+17.29
+17.22
+17.26
+17.3
+17.34
+17.33
+17.39
+17.4
+17.39
+17.48
+17.5
+17.47
+17.43
+17.4
+17.42
+17.46
+17.48
+17.48
+17.46
+17.46
+17.45
+17.43
+17.44
+17.48
+17.43
+17.45
+17.47
+17.46
+17.46
+17.48
+17.48
+17.48
+17.46
+17.5
+17.55
+17.58
+17.57
+17.56
+17.59
+17.61
+17.62
+17.63
+17.62
+17.61
+17.61
+17.62
+17.64
+17.65
+17.61
+17.62
+17.66
+17.65
+17.64
+17.63
+17.64
+17.64
+17.64
+17.63
+17.61
+17.61
+17.62
+17.63
+17.64
+17.65
+17.66
+17.68
+17.69
+17.69
+17.69
+17.66
+17.69
+17.69
+17.62
+17.68
+17.64
+17.65
+17.61
+17.52
+17.56
+17.55
+17.55
+17.48
+17.45
+17.46
+17.46
+17.44
+17.47
+17.5
+17.49
+17.5
+17.53
+17.53
+17.54
+17.51
+17.51
+17.53
+17.53
+17.53
+17.55
+17.55
+17.54
+17.56
+17.59
+17.57
+17.58
+17.58
+17.57
+17.59
+17.57
+17.55
+17.51
+17.51
+17.52
+17.52
+17.53
+17.55
+17.59
+17.61
+17.61
+17.6
+17.6
+17.62
+17.65
+17.62
+17.6
+17.6
+17.62
+17.61
+17.62
+17.63
+17.64
+17.65
+17.61
+17.62
+17.64
+17.63
+17.62
+17.6
+17.57
+17.57
+17.6
+17.59
+17.6
+17.61
+17.61
+17.63
+17.63
+17.59
+17.58
+17.76
+17.79
+17.76
+17.73
+17.74
+17.73
+17.67
+17.66
+17.66
+17.64
+17.63
+17.62
+17.61
+17.6
+17.61
+17.61
+17.6
+17.6
+17.64
+17.65
+17.65
+17.63
+17.61
+17.6
+17.63
+17.63
+17.62
+17.63
+17.64
+17.62
+17.63
+17.65
+17.64
+17.6
+17.59
+17.59
+17.58
+17.58
+17.6
+17.6
+17.6
+17.6
+17.6
+17.58
+17.59
+17.6
+17.6
+17.6
+17.59
+17.59
+17.58
+17.58
+17.65
+17.65