daru 0.1.2 → 0.1.3

data/lib/daru/io/io.rb

@@ -5,12 +5,10 @@ module Daru
         row.to_a.map do |c|
           if empty.include?(c)
             nil
+          elsif c.is_a?(String) && c.is_number?
+            c =~ /^\d+$/ ? c.to_i : c.tr(',','.').to_f
           else
-            if c.is_a? String and c.is_number?
-              c =~ /^\d+$/ ? c.to_i : c.gsub(",",".").to_f
-            else
-              c
-            end
+            c
           end
         end
       end
@@ -23,7 +21,7 @@ module Daru
 
       def from_excel path, opts={}
         opts = {
-          :worksheet_id => 0,
+          worksheet_id: 0
         }.merge opts
 
         worksheet_id = opts[:worksheet_id]
@@ -41,10 +39,10 @@ module Daru
         df
       end
 
-      def dataframe_write_excel dataframe, path, opts={}
+      def dataframe_write_excel dataframe, path, _opts={}
         book   = Spreadsheet::Workbook.new
         sheet  = book.create_worksheet
-        format = Spreadsheet::Format.new :color => :blue, :weight => :bold
+        format = Spreadsheet::Format.new color: :blue, weight: :bold
 
         sheet.row(0).concat(dataframe.vectors.to_a.map(&:to_s)) # Unfreeze strings
         sheet.row(0).default_format = format
@@ -62,18 +60,26 @@ module Daru
         opts[:col_sep]           ||= ','
         opts[:converters]        ||= :numeric
 
-        daru_options = opts.keys.inject({}) do |hash, k|
+        daru_options = opts.keys.each_with_object({}) do |hash, k|
           if [:clone, :order, :index, :name].include?(k)
             hash[k] = opts[k]
             opts.delete k
           end
-
-          hash
         end
 
-        # Preprocess headers for detecting and correcting repetition in 
+        # Preprocess headers for detecting and correcting repetition in
         # case the :headers option is not specified.
-        unless opts[:headers]
+        if opts[:headers]
+          opts[:header_converters] ||= :symbol
+
+          csv = ::CSV.read(path, 'rb',opts)
+          yield csv if block_given?
+
+          hsh = {}
+          csv.by_col.each do |col_name, values|
+            hsh[col_name] = values
+          end
+        else
           csv = ::CSV.open(path, 'rb', opts)
           yield csv if block_given?
 
@@ -86,16 +92,9 @@ module Daru
           headers.each_with_index do |h, i|
             hsh[h] = csv_as_arrays[i]
           end
-        else
-          opts[:header_converters] ||= :symbol
-          
-          csv = ::CSV.read(path, 'rb',opts)
-          yield csv if block_given?
 
-          hsh = {}
-          csv.by_col.each do |col_name, values|
-            hsh[col_name] = values
-          end
+          # Order columns as given in CSV
+          daru_options[:order] = headers.to_a
         end
 
         Daru::DataFrame.new(hsh,daru_options)
@@ -107,14 +106,14 @@ module Daru
         }.merge(opts)
 
         writer = ::CSV.open(path, 'w', options)
-        writer << dataframe.vectors.to_a
+        writer << dataframe.vectors.to_a unless options[:headers] == false
 
         dataframe.each_row do |row|
-          if options[:convert_comma]
-            writer << row.map { |v| v.to_s.gsub('.', ',') }
-          else
-            writer << row.to_a
-          end
+          writer << if options[:convert_comma]
+                      row.map { |v| v.to_s.tr('.', ',') }
+                    else
+                      row.to_a
+                    end
         end
 
         writer.close
@@ -134,10 +133,10 @@ module Daru
 
       def dataframe_write_sql ds, dbh, table
         require 'dbi'
-        query = "INSERT INTO #{table} ("+ds.vectors.to_a.join(",")+") VALUES ("+((["?"]*ds.vectors.size).join(","))+")"
-        sth   =  dbh.prepare(query)
+        query = "INSERT INTO #{table} ("+ds.vectors.to_a.join(',')+') VALUES ('+(['?']*ds.vectors.size).join(',')+')'
+        sth   = dbh.prepare(query)
         ds.each_row { |c| sth.execute(*c.to_a) }
-        return true
+        true
       end
 
       # Load dataframe from AR::Relation
@@ -158,7 +157,7 @@ module Daru
         vectors = Hash[*fields.map { |name|
           [
             name,
-            Daru::Vector.new([]).tap {|v| v.rename name }
+            Daru::Vector.new([]).tap { |v| v.rename name }
           ]
         }.flatten]
 
@@ -174,9 +173,9 @@ module Daru
 
       def from_plaintext filename, fields
         ds = Daru::DataFrame.new({}, order: fields)
-        fp = File.open(filename,"r")
+        fp = File.open(filename,'r')
         fp.each_line do |line|
-          row = Daru::IOHelpers.process_row(line.strip.split(/\s+/),[""])
+          row = Daru::IOHelpers.process_row(line.strip.split(/\s+/),[''])
           next if row == ["\x1A"]
           ds.add_row(row)
         end

data/lib/daru/io/sql_data_source.rb

@@ -9,15 +9,15 @@ module Daru
           @query = query
         end
 
-        def each_column_name(&block)
+        def each_column_name
           result.column_names.each do |column_name|
-            block.(column_name.to_sym)
+            yield(column_name.to_sym)
           end
         end
 
-        def each_row(&block)
+        def each_row
           result.fetch do |row|
-            block.(row.to_a)
+            yield(row.to_a)
           end
         end
 
@@ -36,15 +36,15 @@ module Daru
           @query = query
         end
 
-        def each_column_name(&block)
+        def each_column_name
           result.columns.each do |column_name|
-            block.(column_name.to_sym)
+            yield(column_name.to_sym)
           end
         end
 
-        def each_row(&block)
+        def each_row
           result.each do |row|
-            block.(row.values)
+            yield(row.values)
           end
         end
 
@@ -59,7 +59,7 @@ module Daru
       private_constant :ActiveRecordConnectionAdapter
 
       def self.make_dataframe(db, query)
-        self.new(db, query).make_dataframe
+        new(db, query).make_dataframe
       end
 
       def initialize(db, query)
@@ -105,11 +105,11 @@ module Daru
       end
 
       def check_dbi(obj)
-        DBI::DatabaseHandle === obj rescue false
+        obj.is_a?(DBI::DatabaseHandle)
       end
 
       def check_active_record_connection(obj)
-        ActiveRecord::ConnectionAdapters::AbstractAdapter === obj rescue false
+        obj.is_a?(ActiveRecord::ConnectionAdapters::AbstractAdapter)
       end
     end
   end

data/lib/daru/maths/arithmetic/dataframe.rb

@@ -2,15 +2,14 @@ module Daru
   module Maths
     # Module encapsulating all aritmetic methods on DataFrame.
     module Arithmetic
-      module DataFrame 
-
+      module DataFrame
         # Add a scalar or another DataFrame
         def + other
           binary_operation :+, other
         end
 
         # Subtract a scalar or another DataFrame.
-        def - other 
+        def - other
           binary_operation :-, other
         end
 
@@ -19,7 +18,7 @@ module Daru
           binary_operation :*, other
         end
 
-        # Divide a scalar or another DataFrame. 
+        # Divide a scalar or another DataFrame.
         def / other
           binary_operation :/, other
         end
@@ -36,18 +35,19 @@ module Daru
 
         # Calculate exponenential of all vectors with numeric values.
         def exp
-          only_numerics(clone: false).recode { |v| v.exp }
+          only_numerics(clone: false).recode(&:exp)
         end
 
         # Calcuate square root of numeric vectors.
         def sqrt
-          only_numerics(clone: false).recode { |v| v.sqrt }
+          only_numerics(clone: false).recode(&:sqrt)
         end
 
         def round precision=0
           only_numerics(clone: false).recode { |v| v.round(precision) }
         end
-       private
+
+        private
 
         def binary_operation operation, other
           case other
@@ -59,27 +59,27 @@ module Daru
         end
 
         def dataframe_binary_operation operation, other
-          all_vectors = (self.vectors.to_a | other.vectors.to_a).sort
-          all_indexes = (self.index.to_a   | other.index.to_a).sort
+          all_vectors = (vectors.to_a | other.vectors.to_a).sort
+          all_indexes = (index.to_a   | other.index.to_a).sort
 
           hsh = {}
           all_vectors.each do |vector_name|
-            this = self .has_vector?(vector_name) ? self[vector_name] : nil
+            this = has_vector?(vector_name) ? self[vector_name] : nil
             that = other.has_vector?(vector_name) ? other[vector_name] : nil
 
-            if this and that
-              hsh[vector_name] = this.send(operation, that)
-            else
-              hsh[vector_name] = Daru::Vector.new([], index: all_indexes, 
-                name: vector_name)
-            end
+            hsh[vector_name] =
+              if this && that
+                this.send(operation, that)
+              else
+                Daru::Vector.new([], index: all_indexes, name: vector_name)
+              end
           end
 
-          Daru::DataFrame.new(hsh, index: all_indexes, name: @name, dtype: @dtype)          
+          Daru::DataFrame.new(hsh, index: all_indexes, name: @name, dtype: @dtype)
         end
 
         def scalar_binary_operation operation, other
-          clone = self.dup
+          clone = dup
           clone.map_vectors! do |vector|
             vector = vector.send(operation, other) if vector.type == :numeric
             vector
@@ -90,4 +90,4 @@ module Daru
       end
     end
   end
-end
+end

data/lib/daru/maths/arithmetic/vector.rb

@@ -35,17 +35,17 @@ module Daru
         end
 
         def abs
-          self.recode { |e| e.abs unless e.nil? }
+          recode { |e| e.abs unless e.nil? }
         end
 
         def round precision=0
-          self.recode { |e| e.round(precision) unless e.nil? }
+          recode { |e| e.round(precision) unless e.nil? }
         end
 
-       private
+        private
 
         def math_unary_op operation
-          self.recode { |e| Math.send(operation, e) unless e.nil? }
+          recode { |e| Math.send(operation, e) unless e.nil? }
         end
 
         def binary_op operation, other
@@ -58,8 +58,8 @@ module Daru
         end
 
         def v2o_binary operation, other
-          Daru::Vector.new self.map { |e| e.nil? ? nil : e.send(operation, other) },
-           name: @name, index: @index
+          Daru::Vector.new map { |e| e.nil? ? nil : e.send(operation, other) },
+            name: @name, index: @index
         end
 
         def v2v_binary operation, other
@@ -71,13 +71,8 @@ module Daru
             this = self.index.include?(idx) ? self[idx] : nil
             that = other.index.include?(idx) ? other[idx] : nil
 
-            if this and that
-              elements << this.send(operation ,that)
-              common_idxs << idx
-            else
-              elements << nil
-              common_idxs << idx
-            end
+            elements << (this && that ? this.send(operation, that) : nil)
+            common_idxs << idx
           end
 
           Daru::Vector.new(elements, name: @name, index: common_idxs)
@@ -85,4 +80,4 @@ module Daru
       end
     end
   end
-end
+end

data/lib/daru/maths/statistics/dataframe.rb

@@ -2,45 +2,41 @@ module Daru
   module Maths
     module Statistics
       module DataFrame
-        # Calculate mean of numeric vectors.
-        def mean
-          compute_stats :mean
-        end
-
-        # Calculate sample standard deviation of numeric vectors.
-        def std
-          compute_stats :std
-        end
-
-        # Calculate sum of numeric vectors
-        def sum
-          compute_stats :sum
-        end
-
-        # Count the number of non-nil values in each vector.
-        def count
-          compute_stats :count
+        # @!method mean
+        #   Calculate mean of numeric vectors
+        # @!method variance_sample
+        #   Calculate sample variance of numeric vectors
+        # @!method range
+        #   Calculate range of numeric vectors
+        # @!method median
+        #   Calculate median of numeric vectors
+        # @!method mode
+        #   Calculate mode of numeric vectors
+        # @!method std
+        #   Calculate sample standard deviation of numeric vectors
+        # @!method sum
+        #   Calculate sum of numeric vectors
+        # @!method count
+        #   Count the number of non-nil values in each vector
+        # @!method min
+        #   Calculate the minimum value of each numeric vector
+        # @!method product
+        #   Compute the product of each numeric vector
+        [:mean, :variance_sample, :range, :median, :mode, :std, :sum, :count, :min, :product].each do |meth|
+          define_method(meth) do
+            compute_stats meth
+          end
         end
 
         # Calculate the maximum value of each numeric vector.
         def max opts={}
           if opts[:vector]
-            self.row[*self[opts[:vector]].max_index.index.to_a]
+            row[*self[opts[:vector]].max_index.index.to_a]
           else
             compute_stats :max
           end
         end
 
-        # Calculate the minimmum value of each numeric vector.
-        def min
-          compute_stats :min
-        end
-
-        # Compute the product of each numeric vector.
-        def product
-          compute_stats :product
-        end
-
         # @!method cumsum
         #   Calculate cumulative sum of each numeric Vector
         # @!method standardize
@@ -51,7 +47,7 @@ module Daru
         # @!method ema
         #   Calculate exponential moving average.
         #   @param [Integer] n (10) Loopback length.
-        #   @param [TrueClass, FalseClass, NilClass] wilder (false) If true, 
+        #   @param [TrueClass, FalseClass, NilClass] wilder (false) If true,
         #     1/n value is  used for smoothing; if false, uses 2/(n+1) value.
         # @!method rolling_mean
         #   Calculate moving averages
@@ -74,21 +70,22 @@ module Daru
         # @!method rolling_variance
         #   Calculate moving variance
         #   @param [Integer] n (10) Loopback length. Default to 10.
-        [:cumsum,:standardize,:acf,:ema,:rolling_mean,:rolling_median,:rolling_max,
-         :rolling_min,:rolling_count,:rolling_std,:rolling_variance, :rolling_sum
+        [
+          :cumsum,:standardize,:acf,:ema,:rolling_mean,:rolling_median,:rolling_max,
+          :rolling_min,:rolling_count,:rolling_std,:rolling_variance, :rolling_sum
         ].each do |meth|
           define_method(meth) do |*args|
             apply_method_to_numerics meth, *args
           end
         end
 
-        # Create a summary of mean, standard deviation, count, max and min of 
+        # Create a summary of mean, standard deviation, count, max and min of
         # each numeric vector in the dataframe in one shot.
-        # 
+        #
         # == Arguments
-        # 
-        # +methods+ - An array with aggregation methods specified as symbols to 
-        # be applied to numeric vectors. Default is [:count, :mean, :std, :max, 
+        #
+        # +methods+ - An array with aggregation methods specified as symbols to
+        # be applied to numeric vectors. Default is [:count, :mean, :std, :max,
         # :min]. Methods will be applied in the specified order.
         def describe methods=nil
           methods ||= [:count, :mean, :std, :min, :max]
@@ -100,23 +97,54 @@ module Daru
           Daru::DataFrame.new(description_hash, index: methods)
         end
 
+        # The percent_change method computes the percent change over
+        # the given number of periods for numeric vectors.
+        #
+        # @param [Integer] periods (1) number of nils to insert at the beginning.
+        #
+        # @example
+        #
+        #   df = Daru::DataFrame.new({
+        #        'col0' => [1,2,3,4,5,6],
+        #        'col2' => ['a','b','c','d','e','f'],
+        #        'col1' => [11,22,33,44,55,66]
+        #        },
+        #        index: ['one', 'two', 'three', 'four', 'five', 'six'],
+        #        order: ['col0', 'col1', 'col2'])
+        #   df.percent_change
+        #   #=>
+        #   #   <Daru::DataFrame:23513280 @rows: 6 @cols: 2>
+        #   #              col0                col1
+        #   #   one
+        #   #   two	   1.0	               1.0
+        #   #   three	   0.5                 0.5
+        #   #   four	   0.3333333333333333  0.3333333333333333
+        #   #   five       0.25                0.25
+        #   #   six        0.2                 0.2
+        def percent_change periods=1
+          df_numeric = only_numerics.vectors.to_a
+          df = Daru::DataFrame.new({}, order: @order, index: @index, name: @name)
+          df_numeric.each do |vec|
+            df[vec] = self[vec].percent_change periods
+          end
+          df
+        end
+
         # Calculate sample variance-covariance between the numeric vectors.
         def covariance
           cache={}
-          vectors = self.numeric_vectors
+          vectors = numeric_vectors
 
           mat_rows = vectors.collect do |row|
             vectors.collect do |col|
               if row == col
                 self[row].variance
+              elsif cache[[col,row]].nil?
+                cov = vector_cov(self[row],self[col])
+                cache[[row,col]] = cov
+                cov
               else
-                if cache[[col,row]].nil?
-                  cov = vector_cov(self[row],self[col])
-                  cache[[row,col]] = cov
-                  cov
-                else
-                  cache[[col,row]]
-                end
+                cache[[col,row]]
               end
             end
           end
@@ -125,34 +153,33 @@ module Daru
         end
 
         alias :cov :covariance
-          
+
         # Calculate the correlation between the numeric vectors.
         def correlation
           standard_deviation = std.to_matrix
-          corr_arry = (cov
-            .to_matrix
-            .elementwise_division(standard_deviation.transpose * 
-            standard_deviation)).to_a
+          corr_arry = cov
+                      .to_matrix
+                      .elementwise_division(standard_deviation.transpose *
+            standard_deviation).to_a
 
           Daru::DataFrame.rows(corr_arry, index: numeric_vectors, order: numeric_vectors)
         end
 
         alias :corr :correlation
 
-       private
+        private
 
         def apply_method_to_numerics method, *args
           order = []
-          computed = @vectors.to_a.inject([]) do |memo, n|
+          computed = @vectors.to_a.each_with_object([]) do |n, memo|
             v = @data[@vectors[n]]
             if v.type == :numeric
               memo << v.send(method, *args)
               order << n
             end
-            memo
           end
-          
-          Daru::DataFrame.new(computed, index: @index, order: order ,clone: false) 
+
+          Daru::DataFrame.new(computed, index: @index, order: order,clone: false)
         end
 
         def vector_cov v1a, v2a
@@ -160,23 +187,24 @@ module Daru
         end
 
         def sum_of_squares v1, v2
-          v1a,v2a = v1.only_valid ,v2.only_valid
+          v1a,v2a = v1.only_valid,v2.only_valid
           v1a.reset_index!
-          v2a.reset_index!        
+          v2a.reset_index!
           m1 = v1a.mean
           m2 = v2a.mean
-          (v1a.size).times.inject(0) {|ac,i| ac+(v1a[i]-m1)*(v2a[i]-m2)}
+          v1a.size.times.inject(0) { |ac,i| ac+(v1a[i]-m1)*(v2a[i]-m2) }
         end
 
         def compute_stats method
           Daru::Vector.new(
-            numeric_vectors.inject({}) do |hash, vec|
+            numeric_vectors.each_with_object({}) do |vec, hash|
               hash[vec] = self[vec].send(method)
-              hash
             end, name: method
           )
         end
+        alias :sds :std
+        alias :variance :variance_sample
       end
     end
   end
-end
+end