daru 0.1.0 → 0.1.1

data/spec/math/statistics/dataframe_spec.rb

@@ -49,7 +49,15 @@ describe Daru::DataFrame do
   end
 
   context "#max" do
-    # TODO
+    it "returns the row that has max" do
+      df = Daru::DataFrame.new({
+        a: [1,2,3,4,5],
+        b: ['aa','aaa','a','','dfffdf'],
+        c: [11,22,33,44,55]
+      })
+      expect(df.max(vector: :b)).to eq(
+        Daru::Vector.new([5,'dfffdf',55], index: [:a, :b, :c]))
+    end
   end
 
   context "#min" do
@@ -107,4 +115,34 @@ describe Daru::DataFrame do
       ))
     end
   end
+
+  context "#cumsum" do
+    it "calculates cumulative sum of numeric vectors" do
+      answer = Daru::DataFrame.new({
+        d: [1,3,5,8,11,15,20,26,33],
+        e: [2,6,10,16,22,30,40,52,66],
+        f: [10,30,50,80,110,150,200,260,330]
+        })
+      expect(@df.cumsum).to eq(answer)
+    end
+  end
+
+  context "#rolling_mean" do
+    it "calculates rolling mean" do
+      v = Daru::Vector.new([17.28, 17.45, 17.84, 17.74, 17.82, 17.85, 17.36, 17.3, 17.56, 17.49, 17.46, 17.4, 17.03, 17.01,16.86, 16.86, 16.56, 16.36, 16.66, 16.77])
+      df = Daru::DataFrame.new({ a: v, b: v, c: v })
+      answer = df.rolling_mean
+
+      expect(answer[:a][-1]) .to be_within(0.001).of(16.897)
+      expect(answer[:b][-5]) .to be_within(0.001).of(17.233)
+      expect(answer[:c][-10]).to be_within(0.001).of(17.587)
+    end
+  end
+
+  context "#standardize" do
+    it "standardizes" do
+      # TODO: Write this test.
+      @df.standardize
+    end
+  end
 end

data/spec/math/statistics/vector_spec.rb

@@ -111,6 +111,16 @@ describe Daru::Vector do
         end
       end
 
+      context "#value_counts" do
+        it "counts number of unique values in the Vector" do
+          vector = Daru::Vector.new(
+            ["America","America","America","America","America", 
+              "India","India", "China", "India", "China"])
+          expect(vector.value_counts).to eq(
+            Daru::Vector.new([5,3,2], index: ["America", "India", "China"]))
+        end
+      end
+
       context "#coefficient_of_variation" do
         it "calculates coefficient_of_variation" do
           @dv.coefficient_of_variation
@@ -344,4 +354,156 @@ describe Daru::Vector do
       expect_correct_vector_in_delta(exp, ds[:mean], 1e-13)
     end
   end
-end
+
+  before do
+    # daily closes of iShares XIU on the TSX
+    @shares = Daru::Vector.new([17.28, 17.45, 17.84, 17.74, 17.82, 17.85, 17.36, 17.3, 17.56, 17.49, 17.46, 17.4, 17.03, 17.01,16.86, 16.86, 16.56, 16.36, 16.66, 16.77])
+  end
+
+  context "#acf" do
+    it "calculates autocorrelation co-efficients" do
+      acf = @shares.acf
+
+      expect(acf.length).to eq(14)
+
+      # test the first few autocorrelations
+      expect(acf[0]).to be_within(0.0001).of(1.0)
+      expect(acf[1]).to be_within(0.001) .of(0.852)
+      expect(acf[2]).to be_within(0.001) .of(0.669)
+      expect(acf[3]).to be_within(0.001) .of(0.486)
+    end
+  end
+
+  context "#diff" do
+    it "performs the difference of the series" do
+      diff = @shares.diff
+
+      expect(diff.class).to eq(Daru::Vector)
+      expect(diff[@shares.size - 1]).to be_within(0.001).of( 0.11)
+      expect(diff[@shares.size - 2]).to be_within(0.001).of( 0.30)
+      expect(diff[@shares.size - 3]).to be_within(0.001).of(-0.20)
+    end
+  end
+
+  context "#rolling" do
+    it "calculates rolling mean" do
+      ma10 = @shares.rolling_mean
+
+      expect(ma10[-1]) .to be_within(0.001).of(16.897)
+      expect(ma10[-5]) .to be_within(0.001).of(17.233)
+      expect(ma10[-10]).to be_within(0.001).of(17.587)
+
+      # test with a different lookback period
+      ma5 = @shares.rolling :mean, 5
+
+      expect(ma5[-1]).to be_within(0.001).of(16.642)
+      expect(ma5[-10]).to be_within(0.001).of(17.434)
+      expect(ma5[-15]).to be_within(0.001).of(17.74)      
+    end
+
+    it "calculates rolling median" do
+      me10 = @shares.rolling_median.round(2)
+      expect(me10).to eq(Daru::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,17.525,17.525,17.525,17.475,17.430,17.380,17.330,17.165,17.020,16.94,16.860]).round(2))
+
+      me5 = @shares.rolling(:median, 5).round(2)
+      expect(me5).to eq(Daru::Vector.new([nil,nil,nil,nil,17.74,17.82,17.82,17.74,17.56,17.49,17.46,17.46,17.46,17.40,17.03,17.01,16.86,16.86,16.66,16.66]))
+    end
+
+    it "calculates rolling max" do
+      max10 = @shares.rolling_max.round(2)
+      expect(max10).to eq(Daru::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,17.85,17.85,17.85,17.85,17.85,17.85,17.56,17.56,17.56,17.49,17.46]))
+
+      max5 = @shares.rolling(:max, 5).round(2)
+      expect(max5).to eq(Daru::Vector.new([nil,  nil,  nil,  nil,17.84,17.85,17.85,17.85,17.85,17.85,17.56,17.56,17.56,17.49,17.46,17.40,17.03,17.01,16.86,16.86]))
+    end
+
+    it "calculates rolling min" do
+      min10 = @shares.rolling_min.round(2)
+      expect(min10).to eq(Daru::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,17.28,17.30,17.30,17.03,17.01,16.86,16.86,16.56,16.36,16.36,16.36]))
+
+      min5 = @shares.rolling(:min, 5).round(2)
+      expect(min5).to eq(Daru::Vector.new([nil,nil,nil,nil,17.28,17.45,17.36,17.30,17.30,17.30,17.30,17.30,17.03,17.01,16.86,16.86,16.56,16.36,16.36,16.36]))
+    end
+
+    it "calculates rolling sum" do
+      sum10 = @shares.rolling_sum.round(2)
+      expect(sum10).to eq(Daru::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,175.69,175.87,175.82,175.01,174.28,173.32,172.33,171.53,170.59,169.69,168.97]))
+
+      sum5 = @shares.rolling(:sum, 5).round(2)
+      expect(sum5).to eq(Daru::Vector.new([nil,nil,nil,nil,88.13,88.70,88.61,88.07,87.89,87.56,87.17,87.21,86.94,86.39,85.76,85.16,84.32,83.65,83.30,83.21]))
+    end
+
+    it "calculates rolling std" do
+      std10 = @shares.rolling_std.round(2)
+      expect(std10).to eq(Daru::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,0.227227,0.208116,0.212331,0.253485,0.280666,0.295477,0.267127,0.335826,0.412834,0.388886,0.345995]).round(2))
+
+      std5 = @shares.rolling(:std, 5).round(2)
+      expect(std5).to eq(Daru::Vector.new([nil,nil,nil,nil,0.248556,0.167780,0.206930,0.263211,0.253811,0.215105,0.103827,0.098082,0.208255,0.237844,0.263002,0.220839,0.187963,0.263629,0.212132,0.193959]).round(2))
+    end
+
+    it "calculates rolling variance" do
+      var10 = @shares.rolling_variance.round(2)
+      expect(var10).to eq(Daru::Vector.new([nil,nil,nil,nil,nil,nil,nil,nil,nil,0.051632,0.043312,0.045084,0.064254,0.078773,0.087307,0.071357,0.112779,0.170432,0.151232,0.119712]).round(2))
+
+      var5 = @shares.rolling(:variance, 5).round(2)
+      expect(var5).to eq(Daru::Vector.new([nil,nil,nil,nil,0.06178,0.02815,0.04282,0.06928,0.06442,0.04627,0.01078,0.00962,0.04337,0.05657,0.06917,0.04877,0.03533,0.06950,0.04500,0.03762]).round(2))
+    end
+
+    it "calculates rolling non-nil count" do
+      @shares.rolling_count
+    end
+  end
+
+  context "#ema" do
+    it "calculates exponential moving average" do
+      # test default
+      ema10 = @shares.ema
+
+      expect(ema10[-1]) .to be_within(0.00001).of( 16.87187)
+      expect(ema10[-5]) .to be_within(0.00001).of( 17.19187)
+      expect(ema10[-10]).to be_within(0.00001).of( 17.54918)
+
+      # test with a different lookback period
+      ema5 = @shares.ema 5
+
+      expect(ema5[-1]) .to be_within( 0.0001).of(16.71299)
+      expect(ema5[-10]).to be_within( 0.0001).of(17.49079)
+      expect(ema5[-15]).to be_within( 0.0001).of(17.70067)
+
+      # test with a different smoother
+      ema_w = @shares.ema 10, true
+
+      expect(ema_w[-1]) .to be_within(0.00001).of(17.08044)
+      expect(ema_w[-5]) .to be_within(0.00001).of(17.33219)
+      expect(ema_w[-10]).to be_within(0.00001).of(17.55810)
+    end
+  end
+
+  context "#macd" do
+    it "calculates moving average convergence divergence" do
+      # MACD uses a lot more data than the other ones, so we need a bigger vector
+      data = Daru::Vector.new(
+        File.readlines("spec/fixtures/stock_data.csv").map(&:to_f))
+
+      macd, signal = data.macd
+
+      # check the MACD
+      expect(macd[-1]).to be_within(1e-6).of(3.12e-4)
+      expect(macd[-10]).to be_within(1e-4).of(-1.07e-2)
+      expect(macd[-20]).to be_within(1e-5).of(-5.65e-3)
+
+      # check the signal
+      expect(signal[-1]).to be_within(1e-5).of(-0.00628)
+      expect(signal[-10]).to be_within(1e-5).of(-0.00971)
+      expect(signal[-20]).to be_within(1e-5).of(-0.00338)
+    end
+  end
+
+  context "#cumsum" do
+    it "calculates cumulative sum" do
+      vector = Daru::Vector.new([1,2,3,4,5,6,7,8,9,10])
+      expect(vector.cumsum).to eq(
+        Daru::Vector.new([1,3,6,10,15,21,28,36,45,55]))
+    end
+  end
+end 

data/spec/monkeys_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper.rb'
 
 describe "Monkeys" do
   context Array do
+    it "#recode_repeated" do
+      expect([1,1,'a','a','b',:c,2].recode_repeated).to eq(
+        ['1_1', '1_2','a_1','a_2','b',:c,2])
+    end
   end
 
   context Matrix do

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ require 'matrix'
 require 'awesome_print'
 require 'distribution'
 require 'tempfile'
+require 'pry-byebug'
 
 def mri?
   RUBY_ENGINE == 'ruby'
@@ -18,6 +19,8 @@ else
   require 'nmatrix'
 end
 
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false
+
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))

data/spec/vector_spec.rb

@@ -18,7 +18,7 @@ describe Daru::Vector do
             [:b, :two, :baz]
           ]
 
-          @multi_index = Daru::MultiIndex.new(@tuples)
+          @multi_index = Daru::MultiIndex.from_tuples(@tuples)
         end
 
         it "initializes from an Array" do
@@ -77,6 +77,12 @@ describe Daru::Vector do
           dv = Daru::Vector.new [1,2], name: :mi, index: @multi_index, dtype: :array
           expect(dv).to eq(Daru::Vector.new([1,2,nil,nil], name: :mi, index: @multi_index, dtype: :array))
         end
+
+        it "accepts all sorts of objects for indexing" do
+          dv = Daru::Vector.new [1,2,3,4], index: ['a', 'b', :r, 0]
+          expect(dv.to_a).to eq([1,2,3,4])
+          expect(dv.index.to_a).to eq(['a', 'b', :r, 0])
+        end
       end
 
       context ".new_with_size" do
@@ -147,6 +153,14 @@ describe Daru::Vector do
             expect(@dv[3..4]).to eq(Daru::Vector.new([4,5], name: :yoga, 
               index: [:padme, :r2d2], dtype: dtype))
           end
+
+          it "returns correct results for index of multiple index" do
+            v = Daru::Vector.new([1,2,3,4], index: ['a','c',1,:a])
+            expect(v['a']).to eq(1)
+            expect(v[:a]).to eq(4)
+            expect(v[1]).to eq(3)
+            expect(v[0]).to eq(1)
+          end
         end
 
         context Daru::MultiIndex do
@@ -165,9 +179,10 @@ describe Daru::Vector do
               [:c,:two,:foo],
               [:c,:two,:bar]
             ]
-            @multi_index = Daru::MultiIndex.new(@tuples)
-            @vector = Daru::Vector.new Array.new(12) { |i| i }, index: @multi_index, 
-              dtype: dtype, name: :mi_vector
+            @multi_index = Daru::MultiIndex.from_tuples(@tuples)
+            @vector = Daru::Vector.new(
+              Array.new(12) { |i| i }, index: @multi_index, 
+              dtype: dtype, name: :mi_vector)
           end
 
           it "returns a single element when passed a row number" do
@@ -179,7 +194,7 @@ describe Daru::Vector do
           end
 
           it "returns sub vector when passed first layer of tuple" do
-            mi = Daru::MultiIndex.new([
+            mi = Daru::MultiIndex.from_tuples([
               [:one,:bar],
               [:one,:baz],
               [:two,:bar],
@@ -189,7 +204,7 @@ describe Daru::Vector do
           end
 
           it "returns sub vector when passed first and second layer of tuple" do
-            mi = Daru::MultiIndex.new([
+            mi = Daru::MultiIndex.from_tuples([
               [:foo],
               [:bar]])
             expect(@vector[:c,:two]).to eq(Daru::Vector.new([10,11], index: mi,
@@ -197,7 +212,7 @@ describe Daru::Vector do
           end
 
           it "returns a vector with corresponding MultiIndex when specified numeric Range" do
-            mi = Daru::MultiIndex.new([
+            mi = Daru::MultiIndex.from_tuples([
               [:a,:two,:baz],
               [:b,:one,:bar],
               [:b,:two,:bar],
@@ -233,6 +248,21 @@ describe Daru::Vector do
             @dv[0] = nil
             expect(@dv.dtype).to eq(:array)
           end
+
+          it "assigns correctly for a mixed index Vector" do
+            v = Daru::Vector.new [1,2,3,4], index: ['a',:a,0,66]
+            v['a'] = 666
+            expect(v['a']).to eq(666)
+
+            v[0] = 666
+            expect(v[0]).to eq(666)
+
+            v[3] = 666
+            expect(v[3]).to eq(666)
+
+            expect(v).to eq(Daru::Vector.new([666,2,666,666], 
+              index: ['a',:a,0,66]))
+          end
         end
 
         context Daru::MultiIndex do
@@ -251,7 +281,7 @@ describe Daru::Vector do
               [:c,:two,:foo],
               [:c,:two,:bar]
             ]
-            @multi_index = Daru::MultiIndex.new(@tuples)
+            @multi_index = Daru::MultiIndex.from_tuples(@tuples)
             @vector = Daru::Vector.new Array.new(12) { |i| i }, index: @multi_index, 
               dtype: dtype, name: :mi_vector
           end
@@ -293,21 +323,12 @@ describe Daru::Vector do
           @dv.concat 6, :ibanez
 
           expect(@dv.index)   .to eq(
-            [:warwick, :thompson, :jackson, :fender, :esp, :ibanez].to_index)
+            Daru::Index.new([:warwick, :thompson, :jackson, :fender, :esp, :ibanez]))
           expect(@dv[:ibanez]).to eq(6)
           expect(@dv[5])      .to eq(6)
         end
 
-        it "concatenates without index if index is default numeric" do
-          vector = Daru::Vector.new [1,2,3,4,5], name: :nums, dtype: dtype
-
-          vector.concat 6
-
-          expect(vector.index).to eq([0,1,2,3,4,5].to_index)
-          expect(vector[5])   .to eq(6)
-        end
-
-        it "raises error if index not specified and non-numeric index" do
+        it "raises error if index not specified" do
           expect {
             @dv.concat 6
           }.to raise_error
@@ -320,13 +341,10 @@ describe Daru::Vector do
             dv = Daru::Vector.new [1,2,3,4,5], name: :a, dtype: dtype
 
             dv.delete 3
-            expect(dv).to eq(Daru::Vector.new [1,2,4,5], name: :a)
+            expect(dv).to eq(
+              Daru::Vector.new [1,2,4,5], name: :a, index: [0,1,3,4])
           end
         end
-
-        context Daru::MultiIndex do
-          pending
-        end
       end
 
       context "#delete_at" do
@@ -344,22 +362,19 @@ describe Daru::Vector do
           end
 
           it "deletes element of specified integer index" do
+            pending
             @dv.delete_at 2
 
             expect(@dv).to eq(Daru::Vector.new [1,2,4,5], name: :a, 
               index: [:one, :two, :four, :five], dtype: dtype)
           end
         end
-
-        context Daru::MultiIndex do
-          pending "Possibly next release"
-        end
       end
 
       context "#delete_if" do
         it "deletes elements if block evaluates to true" do
           v = Daru::Vector.new [1,22,33,45,65,32,524,656,123,99,77], dtype: dtype
-          ret = v.delete_if { |d| d % 11 != 0 }
+          ret = v.delete_if { |d| d % 11 == 0 }
           expect(ret).to eq(
             Daru::Vector.new([1,45,65,32,524,656,123], 
               index: [0,3,4,5,6,7,8], dtype: dtype))
@@ -367,6 +382,17 @@ describe Daru::Vector do
         end
       end
 
+      context "#keep_if" do
+        it "keeps elements if block returns true" do
+          v = Daru::Vector.new([1,22,33,45,65,32,524,656,123,99,77], dtype: dtype)
+          ret = v.keep_if { |d| d < 35 }
+
+          expect(ret).to eq(
+            Daru::Vector.new([1,22,33,32], index: [0,1,2,5], dtype: dtype))
+          expect(v.dtype).to eq(ret.dtype)
+        end
+      end
+
       context "#index_of" do
         context Daru::Index do
           it "returns index of specified value" do
@@ -379,7 +405,7 @@ describe Daru::Vector do
 
         context Daru::MultiIndex do
           it "returns tuple of specified value" do
-            mi = Daru::MultiIndex.new([
+            mi = Daru::MultiIndex.from_tuples([
               [:a,:two,:bar],
               [:a,:two,:baz],
               [:b,:one,:bar],
@@ -405,7 +431,7 @@ describe Daru::Vector do
           pending
           # it "returns vector as a Hash" do
           #   pending
-          #   mi = Daru::MultiIndex.new([
+          #   mi = Daru::MultiIndex.from_tuples([
           #     [:a,:two,:bar],
           #     [:a,:two,:baz],
           #     [:b,:one,:bar],
@@ -469,7 +495,7 @@ describe Daru::Vector do
 
         context Daru::MultiIndex do
           before do
-            mi = Daru::MultiIndex.new([
+            mi = Daru::MultiIndex.from_tuples([
               [:a, :one,   :foo], 
               [:a, :two,   :bar], 
               [:b, :one,   :bar], 
@@ -481,7 +507,7 @@ describe Daru::Vector do
           end
 
           it "sorts vector" do
-            mi_asc = Daru::MultiIndex.new([
+            mi_asc = Daru::MultiIndex.from_tuples([
               [:b, :three, :bar],
               [:b, :two,   :baz],
               [:a, :two,   :bar],
@@ -493,7 +519,7 @@ describe Daru::Vector do
           end
 
           it "sorts in descending" do
-            mi_dsc = Daru::MultiIndex.new([
+            mi_dsc = Daru::MultiIndex.from_tuples([
               [:b, :one, :bar], 
               [:a, :one, :foo], 
               [:a, :two, :bar], 
@@ -505,7 +531,7 @@ describe Daru::Vector do
           end
 
           it "sorts using the supplied block" do
-            mi_abs = Daru::MultiIndex.new([
+            mi_abs = Daru::MultiIndex.from_tuples([
               [:b, :two,   :baz],
               [:a, :two,   :bar],
               [:a, :one,   :foo],
@@ -518,29 +544,33 @@ describe Daru::Vector do
         end
       end
 
-      context "#reindex" do
-        context Daru::Index do
-          before do 
-            @dv = Daru::Vector.new [1,2,3,4,5], name: :dv, index: [:a, :b, :c, :d, :e]
-          end
-
-          it "recreates index with sequential numbers" do
-            a  = @dv.reindex(:seq)
+      context "#index=" do
+        before do
+          @vector = Daru::Vector.new([1,2,3,4,5])
+        end
 
-            expect(a).to eq(Daru::Vector.new([1,2,3,4,5], name: :dv, index: [0,1,2,3,4]))
-            expect(a).to_not eq(@dv)
-          end
+        it "simply reassigns index" do
+          index  = Daru::DateTimeIndex.date_range(:start => '2012', :periods => 5)
+          @vector.index = index
 
-          it "accepts a new non-numeric index" do
-            a = @dv.reindex([:hello, :my, :name, :is, :ted])
+          expect(@vector.index.class).to eq(DateTimeIndex)
+          expect(@vector['2012-1-1']).to eq(1)
+        end
 
-            expect(a).to eq(Daru::Vector.new([1,2,3,4,5], name: :dv, index: [:hello, :my, :name, :is, :ted]))
-            expect(a).to_not eq(@dv)
-          end
+        it "raises error for index size != vector size" do
+          expect {
+            @vector.index = Daru::Index.new([4,2,6])
+          }.to raise_error
         end
+      end
 
-        context Daru::MultiIndex do
-          pending
+      context "#reindex" do
+        it "intelligently reindexes" do
+          vector = Daru::Vector.new([1,2,3,4,5])
+          index = Daru::Index.new([3,4,1,0,6])
+
+          expect(vector.reindex(index)).to eq(
+            Daru::Vector.new([4,5,2,1,nil], index: index))
         end
       end
 
@@ -739,7 +769,24 @@ describe Daru::Vector do
     end
 
     context Daru::MultiIndex do
-      pending
+      it "returns indexes of nils" do
+        mi = Daru::MultiIndex.from_tuples([
+          ['M', 2000],
+          ['M', 2001],
+          ['M', 2002],
+          ['M', 2003],
+          ['F', 2000],
+          ['F', 2001],
+          ['F', 2002],
+          ['F', 2003]
+          ])
+        vector = Daru::Vector.new([nil,2,4,5,3,nil,2,nil], index: mi)
+        expect(vector.missing_positions).to eq([
+          ['M',2000], 
+          ['F',2001],
+          ['F',2003]
+        ])
+      end
     end
   end
 
@@ -757,9 +804,9 @@ describe Daru::Vector do
 
   context "#type" do
     before(:each) do
-      @numeric = Daru::Vector.new([1,2,3,4,5])
-      @multi = Daru::Vector.new([1,2,3,'sameer','d'])
-      @with_nils = Daru::Vector.new([1,2,3,4,nil])
+      @numeric    = Daru::Vector.new([1,2,3,4,5])
+      @multi      = Daru::Vector.new([1,2,3,'sameer','d'])
+      @with_nils  = Daru::Vector.new([1,2,3,4,nil])
     end
 
     it "checks numeric data correctly" do
@@ -922,7 +969,7 @@ describe Daru::Vector do
 
     it "stores name as a symbol" do
       @v.rename "This is a vector"
-      expect(@v.name).to eq(:"This is a vector")
+      expect(@v.name).to eq("This is a vector")
     end
   end
 
@@ -966,11 +1013,29 @@ describe Daru::Vector do
 
   context "#detach_index" do
     it "creates a DataFrame with first Vector as index and second as values of the Vector" do
-      v = Daru::Vector.new([1,2,3,4,5,6], index: [:a, :b, :c, :d, :e, :f], name: :values)
+      v = Daru::Vector.new([1,2,3,4,5,6], 
+        index: ['a', 'b', 'c', 'd', 'e', 'f'], name: :values)
       expect(v.detach_index).to eq(Daru::DataFrame.new({
         index: ['a', 'b', 'c', 'd', 'e', 'f'],
-        vector: [1,2,3,4,5,6]
+        values: [1,2,3,4,5,6]
       }))
     end
   end
+
+  context "#lag" do
+    it "lags the vector by specified amount" do
+      xiu = Daru::Vector.new([17.28, 17.45, 17.84, 17.74, 17.82, 17.85, 17.36, 17.3, 17.56, 17.49, 17.46, 17.4, 17.03, 17.01,
+        16.86, 16.86, 16.56, 16.36, 16.66, 16.77])
+      lag1 = xiu.lag
+
+      expect(lag1[lag1.size - 1]).to be_within(0.001).of(16.66)
+      expect(lag1[lag1.size - 2]).to be_within(0.001).of(16.36)
+
+      #test with different lagging unit
+      lag2 = xiu.lag(2)
+
+      expect(lag2[lag2.size - 1]).to be_within(0.001).of(16.36)
+      expect(lag2[lag2.size - 2]).to be_within(0.001).of(16.56)
+    end
+  end
 end if mri?