daru 0.1.0 → 0.1.1

data/lib/daru/io/io.rb

@@ -58,7 +58,6 @@ module Daru
       end
 
       # Functions for loading/writing CSV files
-
       def from_csv path, opts={}
         opts[:col_sep]           ||= ','
         opts[:converters]        ||= :numeric
@@ -79,7 +78,7 @@ module Daru
           yield csv if block_given?
 
           csv_as_arrays = csv.to_a
-          headers       = csv_as_arrays[0].recode_repeated.map(&:to_sym)
+          headers       = csv_as_arrays[0].recode_repeated.map
           csv_as_arrays.delete_at 0
           csv_as_arrays = csv_as_arrays.transpose
 

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

@@ -64,8 +64,8 @@ module Daru
 
           hsh = {}
           all_vectors.each do |vector_name|
-            this = self .has_vector?(vector_name) ? self .vector[vector_name] : nil
-            that = other.has_vector?(vector_name) ? other.vector[vector_name] : nil
+            this = self .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)

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

@@ -68,8 +68,8 @@ module Daru
           index = (@index.to_a | other.index.to_a).sort
 
           index.each do |idx|
-            this = self[idx]
-            that = other[idx]
+            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)

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

@@ -23,8 +23,12 @@ module Daru
         end
 
         # Calculate the maximum value of each numeric vector.
-        def max
-          compute_stats :max
+        def max opts={}
+          if opts[:vector]
+            self.row[*self[opts[:vector]].max_index.index.to_a]
+          else
+            compute_stats :max
+          end
         end
 
         # Calculate the minimmum value of each numeric vector.
@@ -37,13 +41,45 @@ module Daru
           compute_stats :product
         end
 
-        def standardize
-          df = self.only_numerics clone: true
-          df.map! do |v|
-            v.standardize
+        # @!method cumsum
+        #   Calculate cumulative sum of each numeric Vector
+        # @!method standardize
+        #   Standardize each Vector
+        # @!method acf
+        #   Calculate Autocorrelation coefficient
+        #   @param [Integer] max_lags (nil) Number of initial lags
+        # @!method ema
+        #   Calculate exponential moving average.
+        #   @param [Integer] n (10) Loopback length.
+        #   @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
+        #   @param [Integer] n (10) Loopback length. Default to 10.
+        # @!method rolling_median
+        #   Calculate moving median
+        #   @param [Integer] n (10) Loopback length. Default to 10.
+        # @!method rolling_max
+        #   Calculate moving max
+        #   @param [Integer] n (10) Loopback length. Default to 10.
+        # @!method rolling_min
+        #   Calculate moving min
+        #   @param [Integer] n (10) Loopback length. Default to 10.
+        # @!method rolling_count
+        #   Calculate moving non-missing count
+        #   @param [Integer] n (10) Loopback length. Default to 10.
+        # @!method rolling_std
+        #   Calculate moving standard deviation
+        #   @param [Integer] n (10) Loopback length. Default to 10.
+        # @!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
+        ].each do |meth|
+          define_method(meth) do |*args|
+            apply_method_to_numerics meth, *args
           end
-
-          df
         end
 
         # Create a summary of mean, standard deviation, count, max and min of 
@@ -105,6 +141,20 @@ module Daru
 
        private
 
+        def apply_method_to_numerics method, *args
+          order = []
+          computed = @vectors.to_a.inject([]) do |memo, n|
+            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) 
+        end
+
         def vector_cov v1a, v2a
           sum_of_squares(v1a,v2a) / (v1a.size - 1)
         end

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

@@ -122,6 +122,16 @@ module Daru
           end
         end
 
+        # Count number of occurences of each value in the Vector
+        def value_counts
+          values = {}
+          @data.each do |d|
+            values[d] ? values[d] += 1 : values[d] = 1
+          end
+
+          Daru::Vector.new(values)
+        end
+
         def proportion value=1
           frequencies[value].quo(n_valid).to_f
         end
@@ -354,6 +364,225 @@ module Daru
           end
         end
 
+        # Performs the difference of the series.
+        # Note: The first difference of series is X(t) - X(t-1)
+        # But, second difference of series is NOT X(t) - X(t-2)
+        # It is the first difference of the first difference
+        # => (X(t) - X(t-1)) - (X(t-1) - X(t-2))
+        #
+        # == Arguments
+        #
+        #* *max_lags*: integer, (default: 1), number of differences reqd.
+        #
+        # @example Using #diff
+        #
+        #   ts = Daru::Vector.new((1..10).map { rand })
+        #            # => [0.69, 0.23, 0.44, 0.71, ...]
+        #
+        #   ts.diff   # => [nil, -0.46, 0.21, 0.27, ...]
+        #
+        # @return [Daru::Vector]
+        def diff(max_lags = 1)
+          ts = self
+          difference = []
+          max_lags.times do
+            difference = ts - ts.lag
+            ts = difference
+          end
+          difference
+        end
+
+        # Calculate the rolling function for a loopback value.
+        #
+        # @param [Symbol] function The rolling function to be applied. Can be 
+        #   any function applicatble to Daru::Vector (:mean, :median, :count, 
+        #   :min, :max, etc.)
+        # @param [Integer] n (10) A non-negative value which serves as the loopback length.
+        # @return [Daru::Vector] Vector containin rolling calculations.
+        # @example Using #rolling
+        #   ts = Daru::Vector.new((1..100).map { rand })
+        #            # => [0.69, 0.23, 0.44, 0.71, ...]
+        #   # first 9 observations are nil
+        #   ts.rolling(:mean)    # => [ ... nil, 0.484... , 0.445... , 0.513 ... , ... ]
+        def rolling function, n=10
+          Daru::Vector.new(
+            [nil] * (n - 1) + 
+            (0..(size - n)).map do |i|
+              Daru::Vector.new(@data[i...(i + n)]).send(function)
+            end, index: @index
+          )
+        end
+
+        # @!method rolling_mean 
+        #   Calculate rolling average
+        #   @param [Integer] n (10) Loopback length
+        # @!method rolling_median 
+        #   Calculate rolling median
+        #   @param [Integer] n (10) Loopback length
+        # @!method rolling_count
+        #   Calculate rolling non-missing count
+        #   @param [Integer] n (10) Loopback length
+        # @!method rolling_max
+        #   Calculate rolling max value
+        #   @param [Integer] n (10) Loopback length
+        # @!method rolling_min 
+        #   Calculate rolling min value
+        #   @param [Integer] n (10) Loopback length
+        # @!method rolling_sum
+        #   Calculate rolling sum
+        #   @param [Integer] n (10) Loopback length
+        # @!method rolling_std
+        #   Calculate rolling standard deviation
+        #   @param [Integer] n (10) Loopback length
+        # @!method rolling_variance
+        #   Calculate rolling variance
+        #   @param [Integer] n (10) Loopback length
+        [:count, :mean, :median, :max, :min, :sum, :std, :variance].each do |meth|
+          define_method("rolling_#{meth}".to_sym) do |n=10|
+            rolling(meth, n)
+          end
+        end
+
+        # Exponential Moving Average.
+        # 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)
+        #
+        # @param [Integer] n (10) Loopback length.
+        # @param [TrueClass, FalseClass] wilder (false) If true, 1/n value is 
+        #   used for smoothing; if false, uses 2/(n+1) value
+        #
+        # @example Using ema
+        #
+        #   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..., ... ]
+        #
+        # @return [Daru::Vector] Contains EMA
+        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 = @data.index { |i| i != nil }
+          # first n - 1 observations are nil
+          base = [nil] * (start + n - 1)
+          # nth observation is just a moving average
+          base << @data[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
+
+          Daru::Vector.new(base, index: @index)
+        end
+
+        # Moving Average Convergence-Divergence.
+        # Calculates the MACD (moving average convergence-divergence) of the time
+        # series - this is a comparison of a fast EMA with a slow EMA.
+        #
+        # == Arguments
+        #* *fast*: integer, (default = 12) - fast component of MACD
+        #* *slow*: integer, (default = 26) - slow component of MACD
+        #* *signal*: integer, (default = 9) - signal component of MACD
+        #
+        # == Usage
+        #
+        #   ts = Daru::Vector.new((1..100).map { rand })
+        #            # => [0.69, 0.23, 0.44, 0.71, ...]
+        #   ts.macd(13)
+        #
+        # == Returns
+        #
+        # Array of two Daru::Vectors - comparison of fast EMA with slow and EMA with 
+        # signal value
+        def macd(fast = 12, slow = 26, signal = 9)
+          series = ema(fast) - ema(slow)
+          [series, series.ema(signal)]
+        end
+
+        # Calculates the autocorrelation coefficients of the series.
+        #
+        # The first element is always 1, since that is the correlation
+        # of the series with itself.
+        #
+        # @example
+        #   ts = Daru::Vector.new((1..100).map { rand })
+        #
+        #   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
+
+        # Provides autocovariance.
+        #
+        # == Options
+        # 
+        #* *:demean* = true; optional. Supply false if series is not to be demeaned
+        #* *:unbiased* = true; optional. true/false for unbiased/biased form of autocovariance
+        #
+        # == Returns
+        #
+        # Autocovariance value
+        def acvf(demean = true, unbiased = true)
+          opts = {
+            demean: true,
+            unbaised: true
+          }.merge(opts)
+
+          demean   = opts[:demean]
+          unbiased = opts[:unbiased]
+          if demean
+            demeaned_series = self - self.mean
+          else
+            demeaned_series = self
+          end
+
+          n = (10 * Math.log10(size)).to_i + 1
+          m = self.mean
+          if unbiased
+            d = Array.new(self.size, self.size)
+          else
+            d = ((1..self.size).to_a.reverse)[0..n]
+          end
+
+          0.upto(n - 1).map do |i|
+            (demeaned_series * (self.lag(i) - m)).sum / d[i]
+          end
+        end
+
+        # Calculate cumulative sum of Vector
+        def cumsum
+          result = []
+          acc = 0
+          @data.each do |d|
+            if @missing_values.has_key?(d)
+              result << nil
+            else
+              acc += d
+              result << acc
+            end
+          end
+
+          Daru::Vector.new(result, index: @index)
+        end
+
         alias :sdp :standard_deviation_population
         alias :sds :standard_deviation_sample
         alias :std :sds

data/lib/daru/vector.rb

@@ -103,7 +103,7 @@ module Daru
       set_name name
 
       @data  = cast_vector_to(opts[:dtype] || :array, source, opts[:nm_dtype])
-      @index = create_index(index || @data.size)
+      @index = try_create_index(index || @data.size)
       
       if @index.size > @data.size
         cast(dtype: :array) # NM with nils seg faults
@@ -200,32 +200,22 @@ module Daru
     #   # For vectors employing hierarchial multi index
     #   
     def [](*indexes)
-      indexes.map! { |e| e.respond_to?(:to_sym) ? e.to_sym : e }
       location = indexes[0]
       if @index.is_a?(MultiIndex)
+        sub_index = @index[indexes]
         result = 
-        if location.is_a?(Integer)
-          element_from_numeric_index(location)
-        elsif location.is_a?(Range)
-          arry = location.inject([]) do |memo, num|
-            memo << element_from_numeric_index(num)
-            memo
-          end
-
-          new_index = Daru::MultiIndex.new(@index.to_a[location])
-          Daru::Vector.new(arry, index: new_index, name: @name, dtype: dtype)
+        if sub_index.is_a?(Integer)
+          @data[sub_index]
         else
-          sub_index = @index[indexes]
+          elements = sub_index.map do |tuple|
+            @data[@index[tuple]]
+          end
 
-          if sub_index.is_a?(Integer)
-            element_from_numeric_index(sub_index)
-          else
-            elements = sub_index.map do |tuple|
-              @data[@index[(indexes + tuple)]]
-            end
-            Daru::Vector.new(elements, index: Daru::MultiIndex.new(sub_index.to_a),
-              name: @name, dtype: @dtype)
+          if !indexes[0].is_a?(Range) and indexes.size < @index.width
+            sub_index = sub_index.drop_left_level indexes.size
           end
+          Daru::Vector.new(
+            elements, index: sub_index, name: @name, dtype: @dtype)
         end
 
         return result
@@ -233,23 +223,24 @@ module Daru
         unless indexes[1]
           case location
           when Range
-            range = 
-            if location.first.is_a?(Numeric)
-              location
+            first = location.first
+            last  = location.last
+            indexes = @index.slice first, last
+          else
+            pos = @index[location]
+            if pos.is_a?(Numeric)
+              return @data[pos]
             else
-              first = location.first
-              last  = location.last
-
-              (first..last)
+              indexes = pos
             end
-            indexes = @index[range]
-          else
-            return element_from_numeric_index(location)
           end
+        else
+          indexes = indexes.map { |e| named_index_for(e) }
         end
 
-        Daru::Vector.new indexes.map { |loc| @data[index_for(loc)] }, name: @name, 
-          index: indexes.map { |e| named_index_for(e) }, dtype: @dtype
+        Daru::Vector.new(
+          indexes.map { |loc| @data[@index[loc]] }, 
+          name: @name, index: indexes, dtype: @dtype)
       end
     end
 
@@ -274,19 +265,13 @@ module Daru
       @possibly_changed_type = true if @type == :numeric and (!value.is_a?(Numeric) and
         !value.nil?)
 
-      pos =
-      if @index.is_a?(MultiIndex) and !location[0].is_a?(Integer)
-        index_for location
-      else
-        index_for location[0]
-      end
+      location = location[0] unless @index.is_a?(MultiIndex)
+      pos      = @index[location]
 
-      if pos.is_a?(MultiIndex)
-        pos.each do |sub_tuple|
-          self[*(location + sub_tuple)] = value
-        end
-      else
+      if pos.is_a?(Numeric)
         @data[pos] = value
+      else
+        pos.each { |tuple| self[tuple] = value }
       end
 
       set_size
@@ -334,16 +319,132 @@ module Daru
           self[index] == other[index]
         end
       else
-        # TODO: Compare against some other obj (string, number, etc.)
+        super
+      end
+    end
+
+    # !@method eq
+    #   Uses `==` and returns `true` for each **equal** entry
+    #   @param [#==, Daru::Vector] If scalar object, compares it with each
+    #     element in self. If Daru::Vector, compares elements with same indexes.
+    #   @example (see #where)
+    # !@method not_eq
+    #   Uses `!=` and returns `true` for each **unequal** entry
+    #   @param [#!=, Daru::Vector] If scalar object, compares it with each
+    #     element in self. If Daru::Vector, compares elements with same indexes.
+    #   @example (see #where)
+    # !@method lt
+    #   Uses `<` and returns `true` for each entry **less than** the supplied object
+    #   @param [#<, Daru::Vector] If scalar object, compares it with each
+    #     element in self. If Daru::Vector, compares elements with same indexes.
+    #   @example (see #where)
+    # !@method lteq
+    #   Uses `<=` and returns `true` for each entry **less than or equal to** the supplied object
+    #   @param [#<=, Daru::Vector] If scalar object, compares it with each
+    #     element in self. If Daru::Vector, compares elements with same indexes.
+    #   @example (see #where)
+    # !@method mt
+    #   Uses `>` and returns `true` for each entry **more than** the supplied object
+    #   @param [#>, Daru::Vector] If scalar object, compares it with each
+    #     element in self. If Daru::Vector, compares elements with same indexes.
+    #   @example (see #where)
+    # !@method mteq
+    #   Uses `>=` and returns `true` for each entry **more than or equal to** the supplied object
+    #   @param [#>=, Daru::Vector] If scalar object, compares it with each
+    #     element in self. If Daru::Vector, compares elements with same indexes.
+    #   @example (see #where)
+
+    # Define the comparator methods with metaprogramming. See documentation
+    # written above for functionality of each method. Use these methods with the
+    # `where` method to obtain the corresponding Vector/DataFrame.
+    {
+      :eq     => :==,
+      :not_eq => :!=,
+      :lt     => :<,
+      :lteq   => :<=,
+      :mt     => :>,
+      :mteq   => :>=,
+    }.each do |method, operator|
+      define_method(method) do |other|
+        mod = Daru::Core::Query
+        if other.is_a?(Daru::Vector)
+          mod.apply_vector_operator operator, self, other
+        else
+          mod.apply_scalar_operator operator, @data,other  
+        end
       end
     end
+    alias :gt :mt
+    alias :gteq :mteq 
+
+    # Comparator for checking if any of the elements in *other* exist in self.
+    #
+    # @param [Array, Daru::Vector] other A collection which has elements that
+    #   need to be checked for in self.
+    # @example Usage of `in`.
+    #   vector = Daru::Vector.new([1,2,3,4,5])
+    #   vector.where(vector.in([3,5]))
+    #   #=> 
+    #   ##<Daru::Vector:82215960 @name = nil @size = 2 >
+    #   #    nil
+    #   #  2   3
+    #   #  4   5
+    def in other
+      other = Hash[other.zip(Array.new(other.size, 0))]
+      Daru::Core::Query::BoolArray.new(
+        @data.inject([]) do |memo, d|
+          memo << (other.has_key?(d) ? true : false)
+          memo
+        end
+      )
+    end
+
+    # Return a new vector based on the contents of a boolean array. Use with the
+    # comparator methods to obtain meaningful results. See this notebook for 
+    # a good overview of using #where.
+    #
+    # @param [Daru::Core::Query::BoolArray, Array<TrueClass, FalseClass>] bool_arry The 
+    #   collection containing the true of false values. Each element in the Vector
+    #   corresponding to a `true` in the bool_arry will be returned alongwith it's
+    #   index.
+    # @exmaple Usage of #where.
+    #   vector = Daru::Vector.new([2,4,5,51,5,16,2,5,3,2,1,5,2,5,2,1,56,234,6,21])
+    #
+    #   # Simple logic statement passed to #where.
+    #   vector.where(vector.eq(5).or(vector.eq(1)))
+    #   # => 
+    #   ##<Daru::Vector:77626210 @name = nil @size = 7 >
+    #   #    nil
+    #   #  2   5
+    #   #  4   5
+    #   #  7   5
+    #   # 10   1
+    #   # 11   5
+    #   # 13   5
+    #   # 15   1
+    # 
+    #   # A somewhat more complex logic statement
+    #   vector.where((vector.eq(5) | vector.lteq(1)) & vector.in([4,5,1]))
+    #   #=> 
+    #   ##<Daru::Vector:81072310 @name = nil @size = 7 >
+    #   #    nil
+    #   #  2   5
+    #   #  4   5
+    #   #  7   5
+    #   # 10   1
+    #   # 11   5
+    #   # 13   5
+    #   # 15   1
+    def where bool_arry
+      Daru::Core::Query.vector_where @data.to_a, @index.to_a, bool_arry, self.dtype
+    end
 
     def head q=10
       self[0..(q-1)]
     end
 
     def tail q=10
-      self[(@size - q - 1)..(@size-1)]
+      self[(@size - q)..(@size-1)]
     end
 
     # Reports whether missing data is present in the Vector.
@@ -354,20 +455,12 @@ module Daru
 
 
     # Append an element to the vector by specifying the element and index
-    def concat element, index=nil
+    def concat element, index
       raise IndexError, "Expected new unique index" if @index.include? index
 
-      if index.nil? and @index.index_class == Integer
-        @index = create_index(@size + 1)
-        index  = @size
-      else
-        begin
-          @index = create_index(@index + index)
-        rescue StandardError => e
-          raise e, "Expected valid index."
-        end
-      end
+      @index = @index | [index]
       @data[@index[index]] = element
+
       set_size
       set_missing_positions unless Daru.lazy_update
     end
@@ -394,14 +487,8 @@ module Daru
 
     # Delete element by index
     def delete_at index
-      idx = named_index_for index
-      @data.delete_at @index[idx]
-
-      if @index.index_class == Integer
-        @index = Daru::Index.new @size-1
-      else
-        @index = Daru::Index.new (@index.to_a - [idx])
-      end
+      @data.delete_at @index[index]
+      @index = Daru::Index.new(@index.to_a - [index])
 
       set_size
       set_missing_positions unless Daru.lazy_update
@@ -482,9 +569,9 @@ module Daru
     
       order = opts[:ascending] ? :ascending : :descending
       vector, index = send(opts[:type], @data.to_a.dup, @index.to_a, order, &block)
-      index = @index.is_a?(MultiIndex) ? Daru::MultiIndex.new(index) : index
+      index = Daru::Index.new index
 
-      Daru::Vector.new(vector, index: create_index(index), name: @name, dtype: @dtype)
+      Daru::Vector.new(vector, index: index, name: @name, dtype: @dtype)
     end
 
     # Just sort the data and get an Array in return using Enumerable#sort. 
@@ -515,9 +602,31 @@ module Daru
       self
     end
 
+    # Delete an element if block returns true. Destructive.
     def delete_if &block
       return to_enum(:delete_if) unless block_given?
 
+      keep_e = []
+      keep_i = []
+      each_with_index do |n, i|
+        unless yield(n)
+          keep_e << n
+          keep_i << i
+        end
+      end
+
+      @data = cast_vector_to @dtype, keep_e
+      @index = Daru::Index.new(keep_i)
+      set_missing_positions unless Daru.lazy_update
+      set_size
+
+      self
+    end
+
+    # Keep an element if block returns true. Destructive.
+    def keep_if &block
+      return to_enum(:keep_if) unless block_given?
+
       keep_e = []
       keep_i = []
       each_with_index do |n, i|
@@ -528,7 +637,7 @@ module Daru
       end
 
       @data = cast_vector_to @dtype, keep_e
-      @index = @index.is_a?(MultiIndex) ? MultiIndex.new(keep_i) : Index.new(keep_i)
+      @index = Daru::Index.new(keep_i)
       set_missing_positions unless Daru.lazy_update
       set_size
 
@@ -664,10 +773,33 @@ module Daru
       self
     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 = Daru::Vector.new((1..10).map { rand })
+    #           # => [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.dup if k == 0
+
+      dat = @data.to_a.dup
+      (dat.size - 1).downto(k) { |i| dat[i] = dat[i - k] }
+      (0...k).each { |i| dat[i] = nil }
+
+      Daru::Vector.new(dat, index: @index, name: @name)
+    end
+
     def detach_index
       Daru::DataFrame.new({
-        index: @index.to_a.map(&:to_s),
-        vector: @data.to_a
+        index: @index.to_a,
+        values: @data.to_a
       })
     end
 
@@ -826,13 +958,31 @@ module Daru
       content
     end
 
-    # Create a new vector with a different index.
-    # 
-    # @param new_index [Symbol, Array, Daru::Index] The new index. Passing *:seq*
-    #   will reindex with sequential numbers from 0 to (n-1).
+    # Create a new vector with a different index, and preserve the indexing of
+    # current elements.
     def reindex new_index
-      index = create_index(new_index == :seq ? @size : new_index)
-      Daru::Vector.new @data.to_a, index: index, name: name, dtype: @dtype
+      vector = Daru::Vector.new([], index: new_index, name: @name)
+
+      new_index.each do |idx|
+        if @index.include?(idx)
+          vector[idx] = self[idx]
+        else
+          vector[idx] = nil
+        end
+      end
+
+      vector
+    end
+
+    def index= idx
+      raise ArgumentError, 
+        "Size of supplied index #{index.size} does not match size of DataFrame" if 
+        idx.size != self.size
+      raise ArgumentError, "Can only assign type Index and its subclasses." unless 
+        idx.kind_of?(Daru::Index)
+        
+      @index = idx
+      self
     end
 
     # Give the vector a new name
@@ -844,7 +994,7 @@ module Daru
         return
       end
       
-      @name = new_name.to_sym
+      @name = new_name
     end
 
     # Duplicate elements and indexes
@@ -1166,8 +1316,8 @@ module Daru
     def set_name name
       @name = 
       if name.is_a?(Numeric)  then name 
-      elsif name.is_a?(Array) then name.join.to_sym # in case of MultiIndex tuple
-      elsif name              then name.to_sym # anything but Numeric or nil
+      elsif name.is_a?(Array) then name.join # in case of MultiIndex tuple
+      elsif name              then name # anything but Numeric or nil
       else
         nil
       end
@@ -1180,7 +1330,7 @@ module Daru
       end
     end
 
-    def create_index potential_index
+    def try_create_index potential_index
       if potential_index.is_a?(Daru::MultiIndex) or potential_index.is_a?(Daru::Index)
         potential_index
       else