statsample-timeseries 0.0.2

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

@@ -0,0 +1,164 @@
+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)[0][-1]
+          end
+          pacf
+        end
+
+
+        #=Levinson-Durbin Algorithm
+        #==Parameters
+        #* *series*: timeseries, or a series of autocovariances
+        #* *nlags*: integer(default: 10): largest lag to include in recursion or order of the AR process
+        #* *is_acovf*: boolean(default: false): series is timeseries if it is false, else contains autocavariances
+        #
+        #==Returns:
+        #* *sigma_v*: estimate of the error variance
+        #* *arcoefs*: AR coefficients
+        #* *pacf*: pacf function
+        #* *sigma*: some function
+        def self.levinson_durbin(series, nlags = 10, is_acovf = false)
+
+          if is_acovf
+            series = series.map(&:to_f)
+          else
+            #nlags = order(k) of AR in this case
+            series = series.acvf.map(&:to_f)[0..nlags]
+          end
+          #phi = Array.new((nlags+1), 0.0) { Array.new(nlags+1, 0.0) }
+          order = nlags
+          phi = Matrix.zero(nlags + 1)
+          sig = Array.new(nlags+1)
+
+          #setting initial point for recursion:
+          phi[1,1] = series[1]/series[0]
+          #phi[1][1] = series[1]/series[0]
+          sig[1] = series[0] - phi[1, 1] * series[1]
+
+          2.upto(order).each do |k|
+            phi[k, k] = (series[k] - (Statsample::Vector.new(phi[1...k, k-1]) * series[1...k].reverse.to_ts).sum) / sig[k-1]
+            #some serious refinement needed in above for matrix manipulation. Will do today
+            1.upto(k-1).each do |j|
+              phi[j, k] = phi[j, k-1] - phi[k, k] * phi[k-j, k-1]
+            end
+            sig[k] = sig[k-1] * (1-phi[k, k] ** 2)
+
+          end
+          sigma_v = sig[-1]
+          arcoefs_delta = phi.column(phi.column_size - 1)
+          arcoefs = arcoefs_delta[1..arcoefs_delta.size]
+          pacf = diag(phi)
+          pacf[0] = 1.0
+          return [sigma_v, arcoefs, pacf, sig, phi]
+        end
+
+        #Returns diagonal elements of matrices
+        # Will later abstract it to utilities
+        def self.diag(mat)
+          return mat.each_with_index(:diagonal).map { |x, r, c| x }
+        end
+
+
+        #=Yule Walker Algorithm
+        #From the series, estimates AR(p)(autoregressive) parameter using Yule-Waler equation. See -
+        #http://en.wikipedia.org/wiki/Autoregressive_moving_average_model
+        #
+        #==Parameters
+        #* *ts*: timeseries
+        #* *k*: order, default = 1
+        #* *method*: can be 'yw' or 'mle'. If 'yw' then it is unbiased, denominator is (n - k)
+        #
+        #==Returns
+        #* *rho*: autoregressive coefficients
+        #* *sigma*: sigma parameter
+        def self.yule_walker(ts, k = 1, method='yw')
+          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()
+          phi = solve_matrix(mat, r[1..r.size])
+          phi_vector = Statsample::Vector.new(phi, :scale)
+          r_vector = Statsample::Vector.new(r[1..r.size], :scale)
+          sigma = r[0] - (r_vector * phi_vector).sum
+          return [phi, sigma]
+        end
+
+        #=ToEplitz
+        # Generates teoeplitz matrix from an array
+        #http://en.wikipedia.org/wiki/Toeplitz_matrix
+        #Toeplitz matrix are equal when they are stored in row & column major
+        #==Parameters
+        #* *arr*: array of integers;
+        #==Usage
+        #  arr = [0,1,2,3]
+        #  Pacf.toeplitz(arr)
+        #==Returns
+        # [[0, 1, 2, 3],
+        #  [1, 0, 1, 2],
+        #  [2, 1, 0, 1],
+        #  [3, 2, 1, 0]]
+        def self.toeplitz(arr)
+          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
+
+        #===Solves matrix equations
+        #Solves for X in AX = B
+        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/lib/statsample-timeseries/utility.rb

@@ -0,0 +1,154 @@
+module Statsample
+  class Vector
+    include Enumerable
+    include Writable
+    include Summarizable
+
+    #=Squares of sum
+    #==Parameter
+    #* *demean*: boolean - optional. __default__: false
+    #==Returns
+    #Sums the timeseries and then returns the square
+    def squares_of_sum(demean = false)
+      if demean
+        m = self.mean
+        self.map { |x| (x-m) }.sum**2
+      else
+        return self.sum.to_f**2
+      end
+    end
+  end
+
+
+  class ::Matrix
+    #==Squares of sum
+    #Does squares of sum in column order.
+    #Necessary for computations in various processes
+    def squares_of_sum
+      (0...column_size).map do |j|
+        self.column(j).sum**2
+      end
+    end
+
+    #==Symmetric?
+    #`symmetric?` is present in Ruby Matrix 1.9.3+, but not in 1.8.*
+    #===Returns
+    # bool
+    def symmetric?
+      return false unless square?
+
+      (0...row_size).each do |i|
+        0.upto(i).each do |j|
+          return false if self[i, j] != self[j, i]
+        end
+      end
+      true
+    end
+
+    #==Cholesky decomposition
+    #Reference: http://en.wikipedia.org/wiki/Cholesky_decomposition
+    #===Description
+    #Cholesky decomposition is reprsented by `M = L X L*`, where
+    #M is the symmetric matrix and `L` is the lower half of cholesky matrix,
+    #and `L*` is the conjugate form of `L`.
+    #===Returns
+    # Cholesky decomposition for a given matrix(if symmetric)
+    #===Utility
+    # Essential matrix function, requisite in kalman filter, least squares
+    def cholesky
+      raise ArgumentError, "Given matrix should be symmetric" unless symmetric?
+      c = Matrix.zero(row_size)
+      0.upto(row_size - 1).each do |k|
+        0.upto(row_size - 1).each do |i|
+          if i == k
+            sum = (0..(k-1)).inject(0.0){ |sum, j| sum + c[k, j] ** 2 }
+            value = Math.sqrt(self[k,k] - sum)
+            c[k, k] = value
+          elsif i > k
+            sum = (0..(k-1)).inject(0.0){ |sum, j| sum + c[i, j] * c[k, j] }
+            value = (self[k,i] - sum) / c[k, k]
+            c[i, k] = value
+          end
+        end
+      end
+      c
+    end
+
+    #==Chain Product
+    #Class method
+    #Returns the chain product of two matrices
+    #===Usage:
+    #Let `a` be 4 * 3 matrix,
+    #Let `b` be 3 * 3 matrix,
+    #Let `c` be 3 * 1 matrix,
+    #then `Matrix.chain_dot(a, b, c)`
+    #===NOTE:
+    # Send the matrices in multiplicative order with proper dimensions
+    def self.chain_dot(*args)
+      #inspired by Statsmodels
+      begin
+        args.reduce { |x, y| x * y } #perform matrix multiplication in order
+      rescue ExceptionForMatrix::ErrDimensionMismatch
+        puts "ExceptionForMatrix: Please provide matrices with proper multiplicative dimensions"
+      end
+    end
+
+
+    #==Adds a column of constants.
+    #Appends a column of ones to the matrix/array if first argument is false
+    #If an n-array, first checks if one column of ones is already present
+    #if present, then original(self) is returned, else, prepends with a vector of ones
+    def add_constant(prepend = true)
+      #for Matrix
+      (0...column_size).each do |i|
+        if self.column(i).map(&:to_f) == Object::Vector.elements(Array.new(row_size, 1.0))
+          return self
+        end
+      end
+      #append/prepend a column of one's
+      vectors = (0...row_size).map do |r|
+        if prepend
+          [1.0].concat(self.row(r).to_a)
+        else
+          self.row(r).to_a.push(1.0)
+        end
+      end
+      return Matrix.rows(vectors)
+    end
+
+    #populates column i of given matrix with arr
+    def set_column(i, arr)
+      columns = self.column_vectors
+      column = columns[i].to_a
+      column[0...arr.size] = arr
+      columns[i] = column
+      return Matrix.columns(columns)
+    end
+
+    #populates row i of given matrix with arr
+    def set_row(i, arr)
+      #similar implementation as set_column
+      #writing and commenting metaprogrammed version
+      #Please to give opinion :)
+      rows = self.row_vectors
+      row = rows[i].to_a
+      row[0...arr.size] = arr
+      rows[i] = row
+      return Matrix.rows(rows)
+    end
+
+    #Metaprogrammed version of set_column, set_row
+    # self.class_eval do
+    #   ["row", "column"].each do |dimension|
+    #     define_method("set_#{dimension}s") do |i, arr|
+    #       dims = send("#{dimension}_vectors")
+    #       dim = dims[i].to_a
+    #       dim[0...arr.size] = arr
+    #       dims[i] = dim
+    #       return Matrix.send("#{dimension}s", dims)
+    #     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