statsample-timeseries 0.0.3 → 0.3.0

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

@@ -8,7 +8,7 @@ module Statsample
         include GSL::MultiMin if Statsample.has_gsl?
 
         #timeseries object
-        attr_accessor :ts
+        attr_writer :ts
         #Autoregressive order
         attr_accessor :p
         #Integerated part order
@@ -22,14 +22,18 @@ module Statsample
         attr_reader :ma
 
         #Creates a new KalmanFilter object and computes the likelihood
-        def initialize(ts=[].to_ts, p=0, i=0, q=0)
-          @ts = ts
+        def initialize(ts=[], p=0, i=0, q=0)
+          @ts = ts.to_a
           @p = p
           @i = i
           @q = q
           ks #call the filter
         end
 
+        def ts
+          Daru::Vector.new(@ts)
+        end
+
         def to_s
           sprintf("ARIMA model(p = %d, i = %d, q = %d) on series(%d elements) - [%s]",
                   @p, @i, @q, @ts.size, @ts.to_a.join(','))
@@ -54,7 +58,7 @@ module Statsample
             p,q = params[1], params[2]
             params = x
             #puts x
-            -Arima::KF::LogLikelihood.new(x.to_a, timeseries, p, q).ll
+            -Arima::KF::LogLikelihood.new(x.to_a, timeseries, p, q).log_likelihood
             #KalmanFilter.ll(x.to_a, timeseries, p, q)
           }
           np = @p + @q
@@ -71,20 +75,13 @@ module Statsample
           while status == GSL::CONTINUE && iter < 100
             iter += 1
             begin
-              status = minimizer.iterate()
+              status = minimizer.iterate
               status = minimizer.test_size(1e-2)
               x = minimizer.x
             rescue
               break
             end
-          #  printf("%5d ", iter)
-          #  for i in 0...np do
-          #    puts "#{x[i]}.to_f"
-          #    #printf("%10.3e ", x[i].to_f)
-          #  end
-          #  printf("f() = %7.3f size = %.3f\n", minimizer.fval, minimizer.size)
           end
-          #
           @ar = (p > 0) ? x.to_a[0...p] : []
           @ma = (q > 0) ? x.to_a[p...(p+q)] : []
           x.to_a
@@ -112,36 +109,19 @@ module Statsample
           Arima::KF::LogLikelihood.new(params, timeseries, p, q)
         end
 
-        #=T
-        #The coefficient matrix for the state vector in state equation
-        # It's dimensions is r+k x r+k
-        #==Parameters
-        #* *r*: integer, r is max(p, q+1), where p and q are orders of AR and MA respectively
-        #* *k*: integer, number of exogeneous variables in ARMA model
-        #* *q*: integer, The AR coefficient of ARMA model
 
-        #==References Statsmodels tsa, Durbin and Koopman Section 4.7
-        #def self.T(r, k, p)
-        #  arr = Matrix.zero(r)
-        #  params_padded  = Statsample::Vector.new(Array.new(r, 0), :scale)
-        #
-        #  params_padded[0...p] = params[k...(p+k)]
-        #  intermediate_matrix = (r-1).times.map { Array.new(r, 0) }
-        #  #appending an array filled with padded values in beginning
-        #  intermediate_matrix[0,0] = [params_padded]
-        #
-        #  #now generating column matrix for that:
-        #  arr = Matrix.columns(intermediate_matrix)
-        #  arr_00 = arr[0,0]
-        #
-        #  #identify matrix substituition in matrix except row[0] and column[0]
-        #  r.times do |i|
-        #    arr[r,r] = 1
-        #  end
-        #  arr[0,0] = arr_00
-        #  arr
-        #end
+        def self.T(r, k, p)
+          #=T
+          #The coefficient matrix for the state vector in state equation
+          # It's dimensions is r+k x r+k
+          #==Parameters
+          #* *r*: integer, r is max(p, q+1), where p and q are orders of AR and MA respectively
+          #* *k*: integer, number of exogeneous variables in ARMA model
+          #* *q*: integer, The AR coefficient of ARMA model
 
+          #==References Statsmodels tsa, Durbin and Koopman Section 4.7
+          raise NotImplementedError
+        end
       end
     end
   end

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

@@ -16,7 +16,7 @@ module Statsample
 
           def initialize(params, timeseries, p, q)
             @params = params
-            @timeseries = timeseries
+            @timeseries = timeseries.to_a
             @p = p
             @q = q
             ll
@@ -50,7 +50,7 @@ module Statsample
             t = Matrix.zero(m)
             #set_column is available in utility.rb
             t = t.set_column(0, phi)
-            if(m > 1)
+            if m > 1
               t[0...(m-1), 1...m] = Matrix.I(m-1)
               #chances of extra constant 0 values as unbalanced column, so:
               t = Matrix.columns(t.column_vectors)
@@ -66,10 +66,9 @@ module Statsample
 
             n.times do |i|
               v_t[i] = (z * a_t).map { |x| timeseries[i] - x }[0,0]
-
               f_t[i] = (z * p_t * (z.transpose)).map { |x| x + 1 }[0,0]
 
-              k_t = ((t * p_t * z.transpose) + h).map { |x| x / f_t[i] }
+              k_t = ((t * p_t * z.transpose) + h).map { |x| x.quo f_t[i] }
 
               a_t = (t * a_t) + (k_t * v_t[i])
               l_t = t - k_t * z

data/lib/statsample-timeseries/daru_monkeys.rb

@@ -0,0 +1,78 @@
+require '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)
+    Daru::Vector.new(self, *args)
+  end
+
+  alias :to_ts :to_time_series
+end
+
+class Array
+  include Statsample::TimeSeriesShorthands
+end
+
+module Daru
+  class Vector
+    include Statsample::TimeSeries::Pacf
+
+    # = Partial Autocorrelation
+    # Generates partial autocorrelation series for a timeseries
+    #
+    # == Arguments
+    #
+    #* *max_lags*: integer, optional - provide number of lags
+    #* *method*: string. Default: 'yw'.
+    #    * *yw*: For yule-walker algorithm unbiased approach
+    #    * *mle*: For Maximum likelihood algorithm approach
+    #    * *ld*: Forr Levinson-Durbin recursive approach
+    #
+    # == Returns
+    #
+    # array of pacf
+    def pacf(max_lags = nil, method = :yw)
+      helper = Statsample::TimeSeries::Pacf
+      method = method.downcase.to_sym
+      max_lags ||= (10 * Math.log10(size)).to_i
+      if method == :yw or method == :mle
+        helper.pacf_yw(self, max_lags, method.to_s)
+      elsif method == :ld
+        series = self.acvf
+        helper.levinson_durbin(series, max_lags, true)[2]
+      else
+        raise "Method presents for pacf are 'yw', 'mle' or 'ld'"
+      end
+    end
+    
+    # == Autoregressive estimation
+    # Generates AR(k) series for the calling timeseries by yule walker.
+    #
+    # == Parameters
+    #
+    #* *n*: integer, (default = 1500) number of observations for AR.
+    #* *k*: integer, (default = 1) order of AR process.
+    #
+    # == Returns
+    #
+    # Array constituting estimated AR series.
+    def ar(n = 1500, k = 1)
+      series = Statsample::TimeSeries.arima
+      #series = Statsample::TimeSeries::ARIMA.new
+      series.yule_walker(self, n, k)
+    end
+  end
+end
+
+module Statsample
+  module TimeSeries
+
+    # Deprecated. Use Daru::Vector.
+    class Series < Daru::Vector
+      def initialize *args, &block
+        $stderr.puts "This class has been deprecated. Use Daru::Vector directly."
+        super(*args, &block)
+      end
+    end
+  end
+end

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

@@ -1,14 +1,14 @@
 module Statsample
   module TimeSeries
     module Pacf
-      class Pacf
-
-        def self.pacf_yw(timeseries, max_lags, method = 'yw')
+      class << self
+        def pacf_yw(timeseries, max_lags, method = 'yw')
           #partial autocorrelation by yule walker equations.
           #Inspiration: StatsModels
           pacf = [1.0]
+          arr = timeseries.to_a
           (1..max_lags).map do |i|
-            pacf << yule_walker(timeseries, i, method)[0][-1]
+            pacf << yule_walker(arr, i, method)[0][-1]
           end
           pacf
         end
@@ -25,8 +25,7 @@ module Statsample
         #* *arcoefs*: AR coefficients
         #* *pacf*: pacf function
         #* *sigma*: some function
-        def self.levinson_durbin(series, nlags = 10, is_acovf = false)
-
+        def levinson_durbin(series, nlags = 10, is_acovf = false)
           if is_acovf
             series = series.map(&:to_f)
           else
@@ -60,29 +59,34 @@ module Statsample
           return [sigma_v, arcoefs, pacf, sig, phi]
         end
 
-        #Returns diagonal elements of matrices
-        # Will later abstract it to utilities
-        def self.diag(mat)
+        # Returns diagonal elements of matrices
+        def 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
+        # 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
+        # == Returns
+        #
         #* *rho*: autoregressive coefficients
         #* *sigma*: sigma parameter
-        def self.yule_walker(ts, k = 1, method='yw')
-          ts = ts - ts.mean
+        def yule_walker(ts, k = 1, method='yw')
           n = ts.size
-          if method.downcase.eql? 'yw'
+          mean = (ts.inject(:+) / n)
+          ts = ts.map { |t| t - mean }
+
+          if method == 'yw'
             #unbiased => denominator = (n - k)
             denom =->(k) { n - k }
           else
@@ -94,36 +98,41 @@ module Statsample
           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|
+            r[l] = (ts[0...-l].zip(ts[l...n])).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()
+          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
+          phi_vector = phi
+          r_vector = r[1..-1]
+          sigma = r[0] - (r_vector.map.with_index {|e,i| e*phi_vector[i] }).inject(:+)
           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
+        #
+        # 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)
+        #
+        # == Usage
+        #
+        #   arr = [0,1,2,3]
+        #   Pacf.toeplitz(arr)
+        #
+        #   #=>  [[0, 1, 2, 3],
+        #   #=>   [1, 0, 1, 2],
+        #   #=>   [2, 1, 0, 1],
+        #   #=>   [3, 2, 1, 0]]
+        def toeplitz(arr)
           eplitz_matrix = Array.new(arr.size) { Array.new(arr.size) }
 
           0.upto(arr.size - 1) do |i|
@@ -143,9 +152,10 @@ module Statsample
           eplitz_matrix
         end
 
-        #===Solves matrix equations
-        #Solves for X in AX = B
-        def self.solve_matrix(matrix, out_vector)
+        #=Solves matrix equations
+        #
+        # Solves for X in AX = B
+        def solve_matrix(matrix, out_vector)
           solution_vector = Array.new(out_vector.size, 0)
           matrix = matrix.to_a
           k = 0
@@ -157,7 +167,6 @@ module Statsample
           end
           solution_vector
         end
-
       end
     end
   end

data/lib/statsample-timeseries/utility.rb

@@ -1,154 +1,126 @@
-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
+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?
 
-  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
+    (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
 
-    #==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
+  # == 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
-      c
     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
+  #==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
+  #==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
-      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)
+    #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
 
-    #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
+  #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
 end