quandl_operation 0.4.1 → 0.4.2.rc1

data/lib/quandl/operation/core_ext.rb

@@ -2,4 +2,4 @@ require 'quandl/operation/core_ext/array'
 require 'quandl/operation/core_ext/date'
 require 'quandl/operation/core_ext/float'
 require 'quandl/operation/core_ext/string'
-require 'quandl/operation/core_ext/time'
+require 'quandl/operation/core_ext/time'

data/lib/quandl/operation/core_ext/array.rb

@@ -1,22 +1,24 @@
 class Array
   def self.forwardable_methods
-    [:reject, :keep_if, :to_a, :cycle, :drop, :map, :rotate, :each_slice, :pack, :select!, 
-      :combination, :repeated_combination, :shift, :select, :reverse!, :==, :clear, :rotate!, :inspect, :iter_for_each, 
-      :sort_by!, :compact!, :|, :copy_data_simple, :nitems, :zip, :take, :rassoc, :flatten!, :join, :compact, :[]=, 
-      :frozen?, :slice!, :drop_while, :reverse_each, :shuffle, :slice, :reverse, :insert, :uniq, :first, :count, :fetch, 
-      :hash, :to_ary, :find_index, :replace, :-, :product, :iter_for_reverse_each, :pop, :push, :sort, :fill, :uniq!, 
-      :length, :&, :flatten, :repeated_permutation, :[], :shuffle!, :sort!, :sample, :include?, :<<, :dimensions, 
-      :collect, :+, :rindex, :<=>, :eql?, :indices, :collect!, :iter_for_each_index, :iter_for_each_with_index, :index, 
-      :*, :indexes, :copy_data, :delete, :to_s, :assoc, :delete_at, :unshift, :delete_if, :empty?, :reject!, :last, 
-      :size, :concat, :map!, :at, :each_index, :transpose, :values_at, :each, :enum_cons, :group_by, :enum_with_index, 
-      :entries, :with_object, :chunk, :each_with_index, :min, :inject, :one?, :partition, :enum_slice, :none?, :max_by, 
-      :any?, :flat_map, :reduce, :each_entry, :find, :minmax_by, :collect_concat, :each_cons, :member?, :max, :sort_by, 
-      :detect, :all?, :minmax, :grep, :each_with_object, :find_all]
+    [:reject, :keep_if, :to_a, :cycle, :drop, :map, :rotate, :each_slice, :pack, :select!,
+     :combination, :repeated_combination, :shift, :select, :reverse!, :==, :clear, :rotate!, :inspect, :iter_for_each,
+     :sort_by!, :compact!, :|, :copy_data_simple, :nitems, :zip, :take, :rassoc, :flatten!, :join, :compact, :[]=,
+     :frozen?, :slice!, :drop_while, :reverse_each, :shuffle, :slice, :reverse, :insert, :uniq, :first, :count, :fetch,
+     :hash, :to_ary, :find_index, :replace, :-, :product, :iter_for_reverse_each, :pop, :push, :sort, :fill, :uniq!,
+     :length, :&, :flatten, :repeated_permutation, :[], :shuffle!, :sort!, :sample, :include?, :<<, :dimensions,
+     :collect, :+, :rindex, :<=>, :eql?, :indices, :collect!, :iter_for_each_index, :iter_for_each_with_index, :index,
+     :*, :indexes, :copy_data, :delete, :to_s, :assoc, :delete_at, :unshift, :delete_if, :empty?, :reject!, :last,
+     :size, :concat, :map!, :at, :each_index, :transpose, :values_at, :each, :enum_cons, :group_by, :enum_with_index,
+     :entries, :with_object, :chunk, :each_with_index, :min, :inject, :one?, :partition, :enum_slice, :none?, :max_by,
+     :any?, :flat_map, :reduce, :each_entry, :find, :minmax_by, :collect_concat, :each_cons, :member?, :max, :sort_by,
+     :detect, :all?, :minmax, :grep, :each_with_object, :find_all]
   end
+
   def average
-    self.sum / self.count
+    sum / count
   end
+
   def extract_options
     last.is_a?(::Hash) ? last : {}
   end
-end
+end

data/lib/quandl/operation/core_ext/date.rb

@@ -1,55 +1,53 @@
 class Date
-  
   def start_of_frequency(freq)
     case freq.to_sym
     when :daily     then self
-    when :weekly    then self.beginning_of_week
-    when :monthly   then self.beginning_of_month
-    when :quarterly then self.beginning_of_quarter
-    when :annual    then self.beginning_of_year
-    when :annually  then self.beginning_of_year
+    when :weekly    then beginning_of_week
+    when :monthly   then beginning_of_month
+    when :quarterly then beginning_of_quarter
+    when :annual    then beginning_of_year
+    when :annually  then beginning_of_year
     else
       self
     end
   end
-  
+
   def end_of_frequency(freq)
     case freq.to_sym
     when :daily     then self
-    when :weekly    then self.end_of_week
-    when :monthly   then self.end_of_month
-    when :quarterly then self.end_of_quarter
-    when :annual    then self.end_of_year
-    when :annually  then self.end_of_year
+    when :weekly    then end_of_week
+    when :monthly   then end_of_month
+    when :quarterly then end_of_quarter
+    when :annual    then end_of_year
+    when :annually  then end_of_year
     else
       self
     end
   end
-  
-  def ranging_until( date )
+
+  def ranging_until(date)
     self..date
   end
-  
-  def occurrences_of_frequency_ahead( occurrences, freq )
-    occurrences_of_frequency_ago( occurrences.to_i * -1, freq )
+
+  def occurrences_of_frequency_ahead(occurrences, freq)
+    occurrences_of_frequency_ago(occurrences.to_i * -1, freq)
   end
 
-  def occurrences_of_frequency_ago( occurrences, freq )
-    occurrences_of_frequency( occurrences, freq )
+  def occurrences_of_frequency_ago(occurrences, freq)
+    occurrences_of_frequency(occurrences, freq)
   end
 
-  def occurrences_of_frequency( occurrences, freq )
+  def occurrences_of_frequency(occurrences, freq)
     # ensure occurrences is an integer
     occurrences = occurrences.to_i
     case freq.try(:to_sym)
     when :weekly    then self - occurrences.weeks
     when :monthly   then self - occurrences.months
-    when :quarterly then self - ( occurrences * 3 ).months
+    when :quarterly then self - (occurrences * 3).months
     when :annual    then self - occurrences.years
     when :annually  then self - occurrences.years
-    else 
+    else
       self - occurrences
     end
   end
-  
-end
+end

data/lib/quandl/operation/core_ext/float.rb

@@ -1,7 +1,5 @@
 class Float
-
   def microseconds
     (self * 1000.0).to_i
   end
-  
-end
+end

data/lib/quandl/operation/core_ext/string.rb

@@ -1,8 +1,10 @@
 class String
-  
   def numeric?
     return true if self =~ /^\d+$/
-    true if Float(self) rescue false
+    begin
+      true if Float(self)
+    rescue
+      false
+    end
   end
-  
-end
+end

data/lib/quandl/operation/core_ext/time.rb

@@ -1,8 +1,6 @@
 class Time
-  
   class << self
-    
-    def log_elapsed(message=nil, &block)
+    def log_elapsed(message = nil, &block)
       timer = Time.now
       result = block.call
       message = "#{message} (#{timer.elapsed.microseconds}ms)"
@@ -10,56 +8,56 @@ class Time
       Quandl::Logger.info(message)
       result
     end
-  
-    def elapsed(message=nil, &block)
+
+    def elapsed(message = nil, &block)
       log_elapsed(message, &block)
     end
-  
   end
-  
+
   def week_from_beginning_to_end
-    (self.beginning_of_week .. self.end_of_week)
+    (beginning_of_week..end_of_week)
   end
+
   def this_week?
-    self.week_from_beginning_to_end.cover?(Time.now)
+    week_from_beginning_to_end.cover?(Time.now)
   end
 
   def month_from_beginning_to_end
-    (self.beginning_of_month .. self.end_of_month)
+    (beginning_of_month..end_of_month)
   end
+
   def this_month?
-    self.month_from_beginning_to_end.cover?(Time.now)
+    month_from_beginning_to_end.cover?(Time.now)
   end
 
   def round(seconds = 60)
-    Time.at((self.to_f / seconds).round * seconds)
+    Time.at((to_f / seconds).round * seconds)
   end
 
   def floor(seconds = 60)
-    Time.at((self.to_f / seconds).floor * seconds)
+    Time.at((to_f / seconds).floor * seconds)
   end
-  
+
   def microseconds
-    (self.to_f * 1000.0).to_i
+    (to_f * 1000.0).to_i
   end
-  
-  def self.elapsed(message=nil, &block)
+
+  def self.elapsed(message = nil, &block)
     timer = Time.now
     result = block.call
     puts "#{message} (#{timer.elapsed.microseconds}ms)"
     result
   end
-  
+
   def elapsed
     elapsed_since(Time.now)
   end
-  
+
   def elapsed_since(time)
     time - self
   end
-  
+
   def elapsed_ms
     "#{elapsed.microseconds}ms"
   end
-  
-end
+end

data/lib/quandl/operation/qdate.rb

@@ -1,22 +1,18 @@
 module Quandl
-module Operation
-
-class QDate
-
-  class << self
-    def parse(value)
-      date = Date.jd(value.to_i) if value.kind_of?(String) && value.numeric?
-      date = Date.jd(value) if value.is_a?(Integer)
-      date = Date.parse(value) if value.is_a?(String) && value =~ /^[0-9]{4}\-[0-9]{2}\-[0-9]{2}$/
-      date = value if value.is_a?(Date)
-      date = value.to_date if value.respond_to?(:to_date)
-      date
-    rescue
-      nil
+  module Operation
+    class QDate
+      class << self
+        def parse(value)
+          date = Date.jd(value.to_i) if value.is_a?(String) && value.numeric?
+          date = Date.jd(value) if value.is_a?(Integer)
+          date = Date.parse(value) if value.is_a?(String) && value =~ /^[0-9]{4}\-[0-9]{2}\-[0-9]{2}$/
+          date = value if value.is_a?(Date)
+          date = value.to_date if value.respond_to?(:to_date)
+          date
+        rescue
+          nil
+        end
+      end
     end
   end
-
 end
-
-end
-end

data/lib/quandl/operation/sort.rb

@@ -1,33 +1,29 @@
 module Quandl
-module Operation
-class Sort
-  
-  class << self
-    
-    def order?(data)
-      return :none if data.blank? || data[0].blank? || data[1].blank?
-      data[0][0] > data[1][0] ? :desc : :asc
-    end
-    
-    def order(data, order = :asc)
-      # ascending
-      case order
-      when :asc   then data = sort_asc(data)
-      when :desc  then data = sort_desc(data)
-      end
-      data
-    end
+  module Operation
+    class Sort
+      class << self
+        def order?(data)
+          return :none if data.blank? || data[0].blank? || data[1].blank?
+          data[0][0] > data[1][0] ? :desc : :asc
+        end
 
-    def asc(data)
-      data.sort_by{|r| r[0] }
-    end
-    
-    def desc(data)
-      data.sort_by{|r| r[0] }.reverse
+        def order(data, order = :asc)
+          # ascending
+          case order
+          when :asc   then data = sort_asc(data)
+          when :desc  then data = sort_desc(data)
+          end
+          data
+        end
+
+        def asc(data)
+          data.sort_by { |r| r[0] }
+        end
+
+        def desc(data)
+          data.sort_by { |r| r[0] }.reverse
+        end
+      end
     end
-        
   end
-
-end
 end
-end

data/lib/quandl/operation/transform.rb

@@ -1,170 +1,164 @@
 module Quandl
-module Operation
+  module Operation
+    class Transform
+      class << self
+        def perform(data, type)
+          assert_valid_arguments!(data, type)
+          # nothing to do with an empty array
+          return data unless data.compact.present?
+          # original order
+          order = Sort.order?(data)
+          # operations expect data in ascending order
+          data = Sort.asc(data)
+          # transform
+          data = transform(data, type)
+          # return to original order
+          data = Sort.desc(data) if order == :desc
+          # onwards
+          data = Value.precision(data, 14)
+          data
+        end
 
-class Transform
-  
-  class << self
-    
-    def perform( data, type )
-      assert_valid_arguments!(data, type)
-      # nothing to do with an empty array
-      return data unless data.compact.present? 
-      # original order
-      order = Sort.order?(data)
-      # operations expect data in ascending order
-      data = Sort.asc(data)
-      # transform
-      data = transform( data, type)
-      # return to original order
-      data = Sort.desc(data) if order == :desc
-      # onwards
-      data = Value.precision(data, 14)
-      data
-    end
-    
-    def assert_valid_arguments!(data, type)
-      raise ArgumentError, "data must be an Array. Received: #{data.class}" unless data.is_a?(Array)
-      raise ArgumentError, "frequency must be one of #{valid_transformations}. Received: #{type}" unless valid?(type)
-    end
-    
-    def valid_transformation?(type)
-      valid?(type)
-    end
-    
-    def valid?(type)
-      valid_transformations.include?( type.try(:to_sym) )
-    end
-    
-    def valid_transformations
-      [ :diff, :rdiff, :cumul, :normalize, :rdiff_from ]
-    end
-  
-    def transform( data, type)
-      return data if data.blank?
-      #Transforms table from actual data points
-      #to differences between points (:diff)
-      #or a ratio between points(:rdiff)
-      #or a ratio between the latest point and an earlier point (:rdiff_from)
-      #If type is other than these two, nothing is done.
-    
-      # ensure that type is in the expected format
-      type = type.try(:to_sym)
-      # nothing to do unless valid transform
-      return data unless valid_transformation?( type )
-    
-      temparr = Array.new
-      #first make a keylist
-      keylist = data.transpose.first
-      # now sort the keylist from oldest to newest
-      # unless there is only one point
-      if keylist.count > 1
-        keylist = keylist.reverse if keylist[0] > keylist[1] # better performance if we do this first
-        keylist.sort!
-      end
+        def assert_valid_arguments!(data, type)
+          fail ArgumentError, "data must be an Array. Received: #{data.class}" unless data.is_a?(Array)
+          fail ArgumentError, "frequency must be one of #{valid_transformations}. Received: #{type}" unless valid?(type)
+        end
 
-      #find number of columns
-      numcols = data.first.size - 1
-      if type == :normalize
-        divisor = Array.new(numcols,nil)
-        0.upto(keylist.length - 1) do |i|
-          temparr[i] = []
-          curr_row = data[i][1..-1]
-          0.upto(numcols-1) do |x|
-            if curr_row[x].nil?
-              temparr[i][x] = nil
-            elsif divisor[x].nil?
-              if curr_row[x].to_f != 0 
-                divisor[x] = curr_row[x].to_f
-                temparr[i][x] = 100.0
-              else
-                temparr[i][x] = 0
-              end
-            else
-              temparr[i][x] = curr_row[x] / divisor[x] * 100.0
-            end
-          end
+        def valid_transformation?(type)
+          valid?(type)
         end
-        0.upto(keylist.length-1) do |i|
-          data[i] = [keylist[i], temparr[i]].flatten
+
+        def valid?(type)
+          valid_transformations.include?(type.try(:to_sym))
+        end
+
+        def valid_transformations
+          [:diff, :rdiff, :cumul, :normalize, :rdiff_from]
         end
-      elsif [:diff, :rdiff].include? type
-        #now build temparr
-        1.upto(keylist.length - 1) do |i|
-          temparr[i] = []
-          curr_row = data[i][1..-1]
-          prev_row = data[i-1][1..-1]
-          0.upto(numcols-1) do |x| 
-            if type == :diff
-              if !curr_row[x].nil? and !prev_row[x].nil?
-                temparr[i][x] = Float(curr_row[x]) - Float(prev_row[x])
-              else
-                temparr[i][x] = nil
+
+        def transform(data, type)
+          return data if data.blank?
+          # Transforms table from actual data points
+          # to differences between points (:diff)
+          # or a ratio between points(:rdiff)
+          # or a ratio between the latest point and an earlier point (:rdiff_from)
+          # If type is other than these two, nothing is done.
+
+          # ensure that type is in the expected format
+          type = type.try(:to_sym)
+          # nothing to do unless valid transform
+          return data unless valid_transformation?(type)
+
+          temparr = []
+          # first make a keylist
+          keylist = data.transpose.first
+          # now sort the keylist from oldest to newest
+          # unless there is only one point
+          if keylist.count > 1
+            keylist = keylist.reverse if keylist[0] > keylist[1] # better performance if we do this first
+            keylist.sort!
+          end
+
+          # find number of columns
+          numcols = data.first.size - 1
+          if type == :normalize
+            divisor = Array.new(numcols, nil)
+            0.upto(keylist.length - 1) do |i|
+              temparr[i] = []
+              curr_row = data[i][1..-1]
+              0.upto(numcols - 1) do |x|
+                if curr_row[x].nil?
+                  temparr[i][x] = nil
+                elsif divisor[x].nil?
+                  if curr_row[x].to_f != 0
+                    divisor[x] = curr_row[x].to_f
+                    temparr[i][x] = 100.0
+                  else
+                    temparr[i][x] = 0
+                  end
+                else
+                  temparr[i][x] = curr_row[x] / divisor[x] * 100.0
+                end
               end
-            else
-              if !curr_row[x].nil? and !prev_row[x].nil? and prev_row[x] != 0
-                temparr[i][x] = ( Float(curr_row[x]) - Float(prev_row[x]) ) / Float( prev_row[x] )
-              else
-                temparr[i][x] = nil
+            end
+            0.upto(keylist.length - 1) do |i|
+              data[i] = [keylist[i], temparr[i]].flatten
+            end
+          elsif [:diff, :rdiff].include? type
+            # now build temparr
+            1.upto(keylist.length - 1) do |i|
+              temparr[i] = []
+              curr_row = data[i][1..-1]
+              prev_row = data[i - 1][1..-1]
+              0.upto(numcols - 1) do |x|
+                if type == :diff
+                  if !curr_row[x].nil? && !prev_row[x].nil?
+                    temparr[i][x] = Float(curr_row[x]) - Float(prev_row[x])
+                  else
+                    temparr[i][x] = nil
+                  end
+                else
+                  if !curr_row[x].nil? && !prev_row[x].nil? && prev_row[x] != 0
+                    temparr[i][x] = (Float(curr_row[x]) - Float(prev_row[x])) / Float(prev_row[x])
+                  else
+                    temparr[i][x] = nil
+                  end
+                end
               end
             end
-          end
-        end
 
-        #now put temparr into datapac
-        1.upto(keylist.length-1) do |i|
-          data[i] = [keylist[i], temparr[i]].flatten
-        end
-
-        #delete the first date in datapac (because there is no diff for that)
-        data.delete_at(0)
-      elsif type == :rdiff_from
-        num_rows = keylist.length - 1 
-        initial = Array.new(numcols,nil)
-        num_rows.downto(0) do |i|
-          temparr[i] = []
-          curr_row = data[i][1..-1]
-          0.upto(numcols-1) do |x|
-            if curr_row[x].nil?
-              temparr[i][x] = nil
-            elsif initial[x].nil?
-              initial[x] = curr_row[x]
-              temparr[i][x] = 0.0
-            elsif curr_row[x] == 0
-              temparr[i][x] = nil
-            else
-              temparr[i][x] = ( Float(initial[x]) - Float(curr_row[x]) ) / Float(curr_row[x]) 
+            # now put temparr into datapac
+            1.upto(keylist.length - 1) do |i|
+              data[i] = [keylist[i], temparr[i]].flatten
             end
-          end
-        end
 
+            # delete the first date in datapac (because there is no diff for that)
+            data.delete_at(0)
+          elsif type == :rdiff_from
+            num_rows = keylist.length - 1
+            initial = Array.new(numcols, nil)
+            num_rows.downto(0) do |i|
+              temparr[i] = []
+              curr_row = data[i][1..-1]
+              0.upto(numcols - 1) do |x|
+                if curr_row[x].nil?
+                  temparr[i][x] = nil
+                elsif initial[x].nil?
+                  initial[x] = curr_row[x]
+                  temparr[i][x] = 0.0
+                elsif curr_row[x] == 0
+                  temparr[i][x] = nil
+                else
+                  temparr[i][x] = (Float(initial[x]) - Float(curr_row[x])) / Float(curr_row[x])
+                end
+              end
+            end
 
-        0.upto(keylist.length-1) do |i|
-          data[i] = [keylist[i], temparr[i]].flatten
-        end
-      else
-        cumulsum = Array.new(numcols,0)
-        sumstarted = Array.new(numcols,false)
-        #now build temparr
-        0.upto(keylist.length - 1) do |i|
-          temparr[i] = []
-          curr_row = data[i][1..-1]
-          0.upto(numcols-1) do |x|
-            if !curr_row[x].nil?
-              cumulsum[x] = cumulsum[x] + curr_row[x]
-              sumstarted[x] = true
+            0.upto(keylist.length - 1) do |i|
+              data[i] = [keylist[i], temparr[i]].flatten
+            end
+          else
+            cumulsum = Array.new(numcols, 0)
+            sumstarted = Array.new(numcols, false)
+            # now build temparr
+            0.upto(keylist.length - 1) do |i|
+              temparr[i] = []
+              curr_row = data[i][1..-1]
+              0.upto(numcols - 1) do |x|
+                unless curr_row[x].nil?
+                  cumulsum[x] = cumulsum[x] + curr_row[x]
+                  sumstarted[x] = true
+                end
+                temparr[i][x] = cumulsum[x] if sumstarted[x]
+              end
+            end
+            0.upto(keylist.length - 1) do |i|
+              data[i] = [keylist[i], temparr[i]].flatten
             end
-            temparr[i][x] = cumulsum[x] if sumstarted[x]
           end
-        end
-        0.upto(keylist.length-1) do |i|
-          data[i] = [keylist[i],temparr[i]].flatten
+          data
         end
       end
-      data
     end
-    
   end
-  
-end
 end
-end