daru 0.1.5 → 0.3

data/spec/plotting/nyaplot/vector_spec.rb

@@ -12,24 +12,21 @@ describe Daru::Vector, 'plotting' do
 
   it 'plots the vector' do
     expect(plot).to receive(:add).with(:box, [11, 22, 33]).ordered
-    expect(plot).to receive(:show).ordered
 
-    vector.plot(type: :box)
+    expect(vector.plot(type: :box)).to eq plot
   end
 
   context 'scatter' do
     it 'is default type' do
       expect(plot).to receive(:add).with(:scatter, instance_of(Array), instance_of(Array)).ordered
-      expect(plot).to receive(:show).ordered
 
-      vector.plot
+      expect(vector.plot).to eq plot
     end
 
     it 'sets x_axis to 0...size' do
       expect(plot).to receive(:add).with(:scatter, [0, 1, 2], [11, 22, 33]).ordered
-      expect(plot).to receive(:show).ordered
 
-      vector.plot(type: :scatter)
+      expect(vector.plot(type: :scatter)).to eq plot
     end
   end
 
@@ -37,9 +34,8 @@ describe Daru::Vector, 'plotting' do
     context type.to_s do
       it 'does not set x axis' do
         expect(plot).to receive(:add).with(type, [11, 22, 33]).ordered
-        expect(plot).to receive(:show).ordered
 
-        vector.plot(type: type)
+        expect(vector.plot(type: type)).to eq plot
       end
     end
   end
@@ -48,9 +44,8 @@ describe Daru::Vector, 'plotting' do
     context type.to_s do
       it 'sets x axis to index' do
         expect(plot).to receive(:add).with(type, [:a, :b, :c], [11, 22, 33]).ordered
-        expect(plot).to receive(:show).ordered
 
-        vector.plot(type: type)
+        expect(vector.plot(type: type)).to eq plot
       end
     end
   end
@@ -58,7 +53,6 @@ describe Daru::Vector, 'plotting' do
   context 'with block provided' do
     it 'yields plot and diagram' do
       expect(plot).to receive(:add).with(:box, [11, 22, 33]).ordered.and_return(diagram)
-      expect(plot).to receive(:show).ordered
 
       expect { |b| vector.plot(type: :box, &b) }.to yield_with_args(plot, diagram)
     end

data/spec/shared/vector_display_spec.rb

@@ -109,7 +109,7 @@ describe Daru::Vector do
     context '#to_html' do
       let(:doc) { Nokogiri::HTML(vector.to_html) }
       subject(:table) { doc.at('table') }
-      let(:header) { table.at('tr:first-child > th:first-child') }
+      let(:header) { doc.at('b') }
 
       context 'simple' do
         let(:vector) { Daru::Vector.new [1,nil,3],
@@ -119,13 +119,12 @@ describe Daru::Vector do
         describe 'header' do
           subject { header }
           it { is_expected.not_to be_nil }
-          its(['colspan']) { is_expected.to eq '2' }
-          its(:text) { is_expected.to eq "Daru::Vector(3)"\
-            "#{":category" if type == :category}" }
+          its(:text) { is_expected.to eq " Daru::Vector(3)"\
+            "#{":category" if type == :category} " }
         end
 
         describe 'name' do
-          subject(:name) { table.at('tr:nth-child(2) > th:nth-child(2)') }
+          subject(:name) { table.at('thead > tr:first-child > th:nth-child(2)') }
           it { is_expected.not_to be_nil }
           its(:text) { is_expected.to eq 'test' }
 
@@ -151,18 +150,18 @@ describe Daru::Vector do
 
       context 'large vector' do
         subject(:vector) { Daru::Vector.new [1,2,3] * 100, name: 'test', type: type }
-        it 'has only 30 rows (+ 2 header rows, + 2 finishing rows)' do
-          expect(table.search('tr').size).to eq 34
+        it 'has only 30 rows (+ 1 header rows, + 2 finishing rows)' do
+          expect(table.search('tr').size).to eq 33
         end
 
         describe '"skipped" row' do
-          subject(:row) { table.search('tr:nth-child(33) td').map(&:text) }
+          subject(:row) { table.search('tr:nth-child(31) td').map(&:text) }
           its(:count) { is_expected.to eq 2 }
           it { is_expected.to eq ['...', '...'] }
         end
 
         describe 'last row' do
-          subject(:row) { table.search('tr:nth-child(34) td').map(&:text) }
+          subject(:row) { table.search('tr:nth-child(32) td').map(&:text) }
           its(:count) { is_expected.to eq 2 }
           it { is_expected.to eq ['299', '3'] }
         end
@@ -189,19 +188,18 @@ describe Daru::Vector do
         describe 'header' do
           subject { header }
           it { is_expected.not_to be_nil }
-          its(['colspan']) { is_expected.to eq '3' }
-          its(:text) { is_expected.to eq "Daru::Vector(7)"\
-            "#{":category" if type == :category}" }
+          its(:text) { is_expected.to eq " Daru::Vector(7)"\
+            "#{":category" if type == :category} " }
         end
 
         describe 'name row' do
-          subject(:row) { table.at('tr:nth-child(2)').search('th') }
+          subject(:row) { table.at('thead > tr:nth-child(1)').search('th') }
           its(:count) { should == 2 }
           it { expect(row.first['colspan']).to eq '2' }
         end
 
         describe 'first data row' do
-          let(:row) { table.at('tr:nth-child(3)') }
+          let(:row) { table.at('tbody > tr:first-child') }
           subject { row.inner_html.scan(/<t[dh].+?<\/t[dh]>/) }
           it { is_expected.to eq [
             '<th rowspan="3">foo</th>',

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'rspec'
 require 'rspec/its'
+require 'rspec/expectations'
 require 'matrix'
 require 'awesome_print'
 require 'distribution'
@@ -7,6 +8,7 @@ require 'tempfile'
 require 'pry-byebug'
 require 'nokogiri'
 require 'gruff'
+require 'webmock/rspec'
 
 def mri?
   RUBY_ENGINE == 'ruby'
@@ -16,25 +18,27 @@ def jruby?
   RUBY_ENGINE == 'jruby'
 end
 
-if jruby?
-  require 'mdarray'
-else
-  require 'nmatrix/nmatrix'
-end
-
 RSpec::Expectations.configuration.warn_about_potential_false_positives = false
 
 require 'simplecov'
 SimpleCov.start do
   add_filter 'vendor'
   add_filter 'spec'
-  minimum_coverage_by_file 95
+  # minimum_coverage_by_file 95 -- too strict for now. Reconsider after specs redesign.
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'daru'
 
+if jruby?
+  require 'mdarray'
+else
+  if Daru.has_nmatrix?
+    require 'nmatrix/nmatrix'
+  end
+end
+
 ALL_DTYPES = [:nmatrix, :gsl, :array]
 
 # FIXME: This must go! Need to be able to use be_within
@@ -51,6 +55,25 @@ def expect_correct_df_in_delta df1, df2, delta
   end
 end
 
+RSpec::Matchers.define :be_all_within do |delta|
+  match do |actual|
+    expect(@expected).to_not be_nil
+    expect(actual.size).to equal(actual.size)
+    (@act, @exp), @idx = actual.zip(@expected).each_with_index.detect { |(a, e), _| (a - e).abs > delta }
+    @idx.nil?
+  end
+
+  chain :of do |expected|
+    @expected = expected
+  end
+
+  failure_message do |actual|
+    return "expected value must be provided using '.of'." if @expected.nil?
+    return "expected.size must equal actual.size." if @expected.size != actual.size
+    "at index=[#{@idx}], expected '#{actual[@idx]}' to be within '#{delta}' of '#{@expected[@idx]}'."
+  end
+end
+
 class String
   # allows to pretty test agains multiline strings:
   #   %Q{

data/spec/support/matchers.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :be_boolean do
+  match do |actual|
+    expect(actual.is_a?(TrueClass) || actual.is_a?(FalseClass)).to be true
+  end
+end

data/spec/vector_spec.rb

@@ -84,6 +84,11 @@ describe Daru::Vector do
           expect(dv.index.to_a).to eq(['a', 'b', :r, 0])
         end
 
+        it "initializes array with nils with dtype NMatrix" do
+          dv = Daru::Vector.new [2, nil], dtype: :nmatrix
+          expect(dv.to_a).to eq([2, nil])
+          expect(dv.index.to_a).to eq([0, 1])
+        end
       end
 
       context "#reorder!" do
@@ -358,6 +363,9 @@ describe Daru::Vector do
           let (:idx) { Daru::Index.new [1, 0, :c] }
           let (:dv) { Daru::Vector.new ['a', 'b', 'c'], index: idx }
 
+          let (:idx_dt) { Daru::DateTimeIndex.new(['2017-01-01', '2017-02-01', '2017-03-01']) }
+          let (:dv_dt) { Daru::Vector.new(['a', 'b', 'c'], index: idx_dt) }
+
           context "single position" do
             it { expect(dv.at 1).to eq 'b' }
           end
@@ -405,6 +413,15 @@ describe Daru::Vector do
             its(:to_a) { is_expected.to eq ['a'] }
             its(:'index.to_a') { is_expected.to eq [1] }
           end
+
+          context "Splat .at on DateTime index" do
+            subject { dv_dt.at(*[1,2]) }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 2 }
+            its(:to_a) { is_expected.to eq ['b', 'c'] }
+            its(:'index.to_a') { is_expected.to eq ['2017-02-01', '2017-03-01'] }
+          end
         end
 
         context Daru::MultiIndex do
@@ -833,6 +850,24 @@ describe Daru::Vector do
         end
       end
 
+      context '#last' do
+        subject(:vector) do
+          Daru::Vector.new (1..20).to_a, dtype: dtype
+        end
+
+        it 'takes 1 by default' do
+          expect(vector.last).to eq 20
+        end
+
+        it 'takes num if provided' do
+          expect(vector.last(3)).to eq Daru::Vector.new (18..20).to_a, index: (17..19).to_a
+        end
+
+        it 'does not fail on too large num' do
+          expect(vector.last(3000)).to eq vector
+        end
+      end
+
       context "#concat" do
         before :each do
           @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga,
@@ -998,6 +1033,26 @@ describe Daru::Vector do
         its(:to_json) { is_expected.to eq(vector.to_h.to_json) }
       end
 
+      context "#to_s" do
+        before do
+          @v = Daru::Vector.new ["a", "b"], index: [1, 2]
+        end
+
+        it 'produces a class, size description' do
+          expect(@v.to_s).to eq("#<Daru::Vector(2)>")
+        end
+
+        it 'produces a class, name, size description' do
+          @v.name = "Test"
+          expect(@v.to_s).to eq("#<Daru::Vector: Test(2)>")
+        end
+
+        it 'produces a class, name, size description when the name is a symbol' do
+          @v.name = :Test
+          expect(@v.to_s).to eq("#<Daru::Vector: Test(2)>")
+        end
+      end
+
       context "#uniq" do
         before do
           @v = Daru::Vector.new [1, 2, 2, 2.0, 3, 3.0], index:[:a, :b, :c, :d, :e, :f]
@@ -1359,8 +1414,75 @@ describe Daru::Vector do
       end
 
       context "#summary" do
-        it "has name in the summary" do
-          expect(@common_all_dtypes.summary.match("#{@common_all_dtypes.name}")).to_not eq(nil)
+        subject { dv.summary }
+
+        context 'all types' do
+          let(:dv) { Daru::Vector.new([1,2,3,4,5], name: 'vector') }
+
+          it { is_expected.to include dv.name }
+
+          it { is_expected.to include "n :#{dv.size}" }
+
+          it { is_expected.to include "non-missing:#{dv.size - dv.count_values(*Daru::MISSING_VALUES)}" }
+        end
+
+        unless dtype == :nmatrix
+          context "numeric type" do
+            let(:dv) { Daru::Vector.new([1,2,5], name: 'numeric') }
+
+            it { is_expected. to eq %Q{
+                |= numeric
+                |  n :3
+                |  non-missing:3
+                |  median: 2
+                |  mean: 2.6667
+                |  std.dev.: 2.0817
+                |  std.err.: 1.2019
+                |  skew: 0.2874
+                |  kurtosis: -2.3333
+              }.unindent }
+          end
+
+          context "numeric type with missing values" do
+            let(:dv) { Daru::Vector.new([1,2,5,nil,Float::NAN], name: 'numeric') }
+
+            it { is_expected.not_to include 'skew' }
+            it { is_expected.not_to include 'kurtosis' }
+          end
+        end
+
+        if dtype == :array
+          context "object type" do
+            let(:dv) { Daru::Vector.new([1,1,2,2,"string",nil,Float::NAN], name: 'object') }
+
+            if RUBY_VERSION >= '2.2'
+              it { is_expected.to eq %Q{
+                  |= object
+                  |  n :7
+                  |  non-missing:5
+                  |  factors: 1,2,string
+                  |  mode: 1,2
+                  |  Distribution
+                  |          string       1  50.00%
+                  |             NaN       1  50.00%
+                  |               1       2 100.00%
+                  |               2       2 100.00%
+                }.unindent }
+            else
+              it { is_expected.to eq %Q{
+                |= object
+                |  n :7
+                |  non-missing:5
+                |  factors: 1,2,string
+                |  mode: 1,2
+                |  Distribution
+                |             NaN       1  50.00%
+                |          string       1  50.00%
+                |               2       2 100.00%
+                |               1       2 100.00%
+              }.unindent }
+            end
+          end
         end
       end
 
@@ -1388,27 +1510,19 @@ describe Daru::Vector do
     end
   end
 
-  context "#is_nil?" do
-    before(:each) do
-      @with_md    = Daru::Vector.new([1,2,nil,3,4,nil])
-      @without_md = Daru::Vector.new([1,2,3,4,5,6])
-    end
-
-    it "verifies missing data presence" do
-      expect(@with_md.is_nil?)   .to eq(Daru::Vector.new([false,false,true,false,false,true]))
-      expect(@without_md.is_nil?).to eq(Daru::Vector.new([false,false,false,false,false,false]))
-    end
-  end
+  context '#is_values' do
+    let(:dv) { Daru::Vector.new [10, 11, 10, nil, nil] }
 
-  context "#not_nil?" do
-    before(:each) do
-      @with_md    = Daru::Vector.new([1,2,nil,3,4,nil])
-      @without_md = Daru::Vector.new([1,2,3,4,5,6])
+    context 'single value' do
+      subject { dv.is_values 10 }
+      it { is_expected.to be_a Daru::Vector }
+      its(:to_a) { is_expected.to eq [true, false, true, false, false] }
     end
 
-    it "verifies missing data presence" do
-      expect(@with_md.not_nil?)   .to eq(Daru::Vector.new([true,true,false,true,true,false]))
-      expect(@without_md.not_nil?).to eq(Daru::Vector.new([true,true,true,true,true,true]))
+    context 'multiple values' do
+      subject { dv.is_values 10, nil }
+      it { is_expected.to be_a Daru::Vector }
+      its(:to_a) { is_expected.to eq [true, false, true, true, true] }
     end
   end
 
@@ -1433,7 +1547,7 @@ describe Daru::Vector do
       index: 11..18 }
     context 'reject only nils' do
       subject { dv.reject_values nil }
-      
+
       it { is_expected.to be_a Daru::Vector }
       its(:to_a) { is_expected.to eq [1, 3, :a, Float::NAN, Float::NAN, 1] }
       its(:'index.to_a') { is_expected.to eq [11, 13, 14, 15, 17, 18] }
@@ -1441,7 +1555,7 @@ describe Daru::Vector do
 
     context 'reject only float::NAN' do
       subject { dv.reject_values Float::NAN }
-      
+
       it { is_expected.to be_a Daru::Vector }
       its(:to_a) { is_expected.to eq [1, nil, 3, :a, nil, 1] }
       its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 16, 18] }
@@ -1449,15 +1563,15 @@ describe Daru::Vector do
 
     context 'reject both nil and float::NAN' do
       subject { dv.reject_values nil, Float::NAN }
-      
+
       it { is_expected.to be_a Daru::Vector }
       its(:to_a) { is_expected.to eq [1, 3, :a, 1] }
       its(:'index.to_a') { is_expected.to eq [11, 13, 14, 18] }
     end
-    
+
     context 'reject any other value' do
       subject { dv.reject_values 1, 3 }
-      
+
       it { is_expected.to be_a Daru::Vector }
       its(:to_a) { is_expected.to eq [nil, :a, Float::NAN, nil, Float::NAN] }
       its(:'index.to_a') { is_expected.to eq [12, 14, 15, 16, 17] }
@@ -1465,25 +1579,25 @@ describe Daru::Vector do
 
     context 'when resultant vector has only one value' do
       subject { dv.reject_values 1, :a, nil, Float::NAN }
-      
+
       it { is_expected.to be_a Daru::Vector }
       its(:to_a) { is_expected.to eq [3] }
       its(:'index.to_a') { is_expected.to eq [13] }
     end
-    
+
     context 'when resultant vector has no value' do
       subject { dv.reject_values 1, 3, :a, nil, Float::NAN, 5 }
-      
+
       it { is_expected.to be_a Daru::Vector }
       its(:to_a) { is_expected.to eq [] }
       its(:'index.to_a') { is_expected.to eq [] }
     end
-    
+
     context 'works for gsl' do
       let(:dv) { Daru::Vector.new [1, 2, 3, Float::NAN], dtype: :gsl,
         index: 11..14 }
       subject { dv.reject_values Float::NAN }
-      
+
       it { is_expected.to be_a Daru::Vector }
       its(:dtype) { is_expected.to eq :gsl }
       its(:to_a) { is_expected.to eq [1, 2, 3].map(&:to_f) }
@@ -1501,31 +1615,31 @@ describe Daru::Vector do
 
       context 'reject only nils' do
         subject { dv.reject_values nil }
-        
+
         it { is_expected.to be_a Daru::Vector }
         its(:to_a) { is_expected.to eq [1, 3, :a, Float::NAN, Float::NAN, 1] }
         its(:'index.to_a') { is_expected.to eq [11, 13, 14, 15, 17, 18] }
       end
-  
+
       context 'reject only float::NAN' do
         subject { dv.reject_values Float::NAN }
-        
+
         it { is_expected.to be_a Daru::Vector }
         its(:to_a) { is_expected.to eq [1, nil, 3, :a, nil, 1] }
         its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 16, 18] }
       end
-  
+
       context 'reject both nil and float::NAN' do
         subject { dv.reject_values nil, Float::NAN }
-        
+
         it { is_expected.to be_a Daru::Vector }
         its(:to_a) { is_expected.to eq [1, 3, :a, 1] }
         its(:'index.to_a') { is_expected.to eq [11, 13, 14, 18] }
       end
-      
+
       context 'reject any other value' do
         subject { dv.reject_values 1, 3 }
-        
+
         it { is_expected.to be_a Daru::Vector }
         its(:to_a) { is_expected.to eq [nil, :a, Float::NAN, nil, Float::NAN] }
         its(:'index.to_a') { is_expected.to eq [12, 14, 15, 16, 17] }
@@ -1563,24 +1677,24 @@ describe Daru::Vector do
         let(:dv) { Daru::Vector.new [1, Float::NAN, 2, 3] }
         it { expect(dv.include_values? nil, Float::NAN).to eq true }
       end
-      
+
       context 'true with only Float::NAN' do
         let(:dv) { Daru::Vector.new [1, nil, 2, 3] }
         it { expect(dv.include_values? nil, Float::NAN).to eq true }
       end
-      
+
       context 'false' do
         let(:dv) { Daru::Vector.new [1, 2, 3] }
         it { expect(dv.include_values? nil, Float::NAN).to eq false }
       end
     end
-    
+
     context 'any other value' do
       context 'true' do
         let(:dv) { Daru::Vector.new [1, 2, 3, 4, nil] }
         it { expect(dv.include_values? 1, 2, 3, 5).to eq true }
       end
-      
+
       context 'false' do
         let(:dv) { Daru::Vector.new [1, 2, 3, 4, nil] }
         it { expect(dv.include_values? 5, 6).to eq false }
@@ -1600,12 +1714,12 @@ describe Daru::Vector do
     context Daru::Index do
       let(:dv) { Daru::Vector.new [1, 2, 1, 2, 3, nil, nil, Float::NAN],
         index: 11..18 }
-      
+
       subject { dv.indexes 1, 2, nil, Float::NAN }
       it { is_expected.to be_a Array }
       it { is_expected.to eq [11, 12, 13, 14, 16, 17, 18] }
     end
-    
+
     context Daru::MultiIndex do
       let(:mi) do
         Daru::MultiIndex.from_tuples([
@@ -1621,7 +1735,7 @@ describe Daru::Vector do
       end
       let(:dv) { Daru::Vector.new [1, 2, 1, 2, 3, nil, nil, Float::NAN],
         index: mi }
-      
+
       subject { dv.indexes 1, 2, Float::NAN }
       it { is_expected.to be_a Array }
       it { is_expected.to eq(
@@ -1634,7 +1748,7 @@ describe Daru::Vector do
         ]) }
     end
   end
-  
+
   context '#replace_values' do
     subject do
       Daru::Vector.new(
@@ -1647,13 +1761,13 @@ describe Daru::Vector do
       before { subject.replace_values [nil, Float::NAN], 10 }
       its(:to_a) { is_expected.to eq [1, 2, 1, 4, 10, 10, 10, 10] }
     end
-    
+
     context 'replace arbitrary values' do
       before { subject.replace_values [1, 2], 10 }
       its(:to_a) { is_expected.to eq(
         [10, 10, 10, 4, nil, Float::NAN, nil, Float::NAN]) }
     end
-    
+
     context 'works for single value' do
       before { subject.replace_values nil, 10 }
       its(:to_a) { is_expected.to eq(
@@ -1673,6 +1787,61 @@ describe Daru::Vector do
     end
   end
 
+  context '#rolling_fillna!' do
+    subject do
+      Daru::Vector.new(
+        [Float::NAN, 2, 1, 4, nil, Float::NAN, 3, nil, Float::NAN]
+      )
+    end
+
+    context 'rolling_fillna! forwards' do
+      before { subject.rolling_fillna!(:forward) }
+      its(:to_a) { is_expected.to eq [0, 2, 1, 4, 4, 4, 3, 3, 3] }
+    end
+
+    context 'rolling_fillna! backwards' do
+      before { subject.rolling_fillna!(direction: :backward) }
+      its(:to_a) { is_expected.to eq [2, 2, 1, 4, 3, 3, 3, 0, 0] }
+    end
+
+    context 'all invalid vector' do
+      subject do
+        Daru::Vector.new(
+          [Float::NAN, Float::NAN, Float::NAN, Float::NAN, Float::NAN]
+        )
+      end
+      before { subject.rolling_fillna!(:forward) }
+      its(:to_a) { is_expected.to eq [0, 0, 0, 0, 0] }
+    end
+
+    context 'with non-default index' do
+      subject do
+        Daru::Vector.new(
+          [Float::NAN, 2, 1, 4, nil, Float::NAN, 3, nil, Float::NAN],
+          index: %w[a b c d e f g h i]
+        )
+      end
+      before { subject.rolling_fillna!(direction: :backward) }
+      it { is_expected.to eq Daru::Vector.new([2, 2, 1, 4, 3, 3, 3, 0, 0], index: %w[a b c d e f g h i]) }
+    end
+  end
+
+  context '#rolling_fillna' do
+    subject do
+      Daru::Vector.new(
+        [Float::NAN, 2, 1, 4, nil, Float::NAN, 3, nil, Float::NAN]
+      )
+    end
+
+    context 'rolling_fillna forwards' do
+      it { expect(subject.rolling_fillna(:forward).to_a).to eq [0, 2, 1, 4, 4, 4, 3, 3, 3] }
+    end
+
+    context 'rolling_fillna backwards' do
+      it { expect(subject.rolling_fillna(direction: :backward).to_a).to eq [2, 2, 1, 4, 3, 3, 3, 0, 0] }
+    end
+  end
+
   context "#type" do
     before(:each) do
       @numeric    = Daru::Vector.new([1,2,3,4,5])
@@ -1741,7 +1910,7 @@ describe Daru::Vector do
 
   context '#to_nmatrix' do
     let(:dv) { Daru::Vector.new [1, 2, 3, 4, 5] }
-    
+
     context 'horizontal axis' do
       subject { dv.to_nmatrix }
 
@@ -1749,19 +1918,19 @@ describe Daru::Vector do
       its(:shape) { is_expected.to eq [1, 5] }
       its(:to_a) { is_expected.to eq [1, 2, 3, 4, 5] }
     end
-    
+
     context 'vertical axis' do
       subject { dv.to_nmatrix :vertical }
-      
+
       it { is_expected.to be_a NMatrix }
       its(:shape) { is_expected.to eq [5, 1] }
       its(:to_a) { is_expected.to eq [1, 2, 3, 4, 5].map { |i| [i] } }
     end
-    
+
     context 'invalid axis' do
       it { expect { dv.to_nmatrix :hello }.to raise_error ArgumentError }
     end
-    
+
     context 'vector contain non-numeric' do
       let(:dv) { Daru::Vector.new [1, 2, nil, 4] }
       it { expect { dv.to_nmatrix }.to raise_error ArgumentError }
@@ -1904,52 +2073,90 @@ describe Daru::Vector do
     end
   end
 
-  context "#lag" do
-    before 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])
+  describe '#lag' do
+    let(:source) { Daru::Vector.new(1..5) }
+
+    context 'by default' do
+      subject { source.lag }
+      it { is_expected.to eq Daru::Vector.new([nil, 1, 2, 3, 4]) }
     end
 
-    it "lags the vector by specified amount" do
-      lag1 = @xiu.lag
+    subject { source.lag(amount) }
 
-      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)
+    context '0' do
+      let(:amount) { 0 }
+      it { is_expected.to eq Daru::Vector.new([1, 2, 3, 4, 5]) }
+    end
 
-      #test with different lagging unit
-      lag2 = @xiu.lag(2)
+    context 'same as vector size' do
+      let(:amount) { source.size }
+      it { is_expected.to eq Daru::Vector.new([nil]*source.size) }
+    end
+
+    context 'same as vector -ve size' do
+      let(:amount) { -source.size }
+      it { is_expected.to eq Daru::Vector.new([nil]*source.size) }
+    end
+
+    context 'positive' do
+      let(:amount) { 2 }
+      it { is_expected.to eq Daru::Vector.new([nil, nil, 1, 2, 3]) }
+    end
+
+    context 'negative' do
+      let(:amount) { -1 }
+      it { is_expected.to eq Daru::Vector.new([2, 3, 4, 5, nil]) }
+    end
 
-      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)
+    context 'large positive' do
+      let(:amount) { source.size + 100 }
+      it { is_expected.to eq Daru::Vector.new([nil]*source.size) }
     end
+
+    context 'large negative' do
+      let(:amount) { -(source.size + 100) }
+      it { is_expected.to eq Daru::Vector.new([nil]*source.size) }
+    end
+
   end
-  
+
   context "#group_by" do
     let(:dv) { Daru::Vector.new [:a, :b, :a, :b, :c] }
-    
+
     context 'vector not specified' do
-      subject { dv.group_by }  
-          
+      subject { dv.group_by }
+
       it { is_expected.to be_a Daru::Core::GroupBy }
       its(:'groups.size') { is_expected.to eq 3 }
       its(:groups) { is_expected.to eq({[:a]=>[0, 2], [:b]=>[1, 3], [:c]=>[4]}) }
     end
-    
+
     context 'vector name specified' do
       before { dv.name = :hello }
       subject { dv.group_by :hello }
-      
+
       it { is_expected.to be_a Daru::Core::GroupBy }
       its(:'groups.size') { is_expected.to eq 3 }
-      its(:groups) { is_expected.to eq({[:a]=>[0, 2], [:b]=>[1, 3], [:c]=>[4]}) }            
+      its(:groups) { is_expected.to eq({[:a]=>[0, 2], [:b]=>[1, 3], [:c]=>[4]}) }
     end
-    
+
     context 'vector name invalid' do
       before { dv.name = :hello }
       it { expect { dv.group_by :abc }.to raise_error }
     end
   end
 
+  context '#match' do
+    subject { dv.match(regexp) }
+
+    context 'returns matching array for a given regexp' do
+      let(:dv)     { Daru::Vector.new ['3 days', '5 weeks', '2 weeks'] }
+      let(:regexp) { /weeks/ }
+
+      it { is_expected.to eq([false, true, true]) }
+    end
+  end
+  
   context '#method_missing' do
     context 'getting' do
       subject(:vector) { Daru::Vector.new [1,2,3], index: [:a, :b, :c] }
@@ -1974,6 +2181,24 @@ describe Daru::Vector do
     end
   end
 
+  context "#sort_by_index" do
+    let(:asc) { vector.sort_by_index }
+    let(:desc) { vector.sort_by_index(ascending: false) }
+
+    context 'numeric vector' do
+      let(:vector) { Daru::Vector.new [11, 13, 12], index: [23, 21, 22] }
+      specify { expect(asc.to_a).to eq [13, 12, 11] }
+      specify { expect(desc.to_a).to eq [11, 12, 13] }
+    end
+
+    context 'mix variable type index' do
+      let(:vector) { Daru::Vector.new [11, Float::NAN, nil],
+                              index: [21, 23, 22] }
+      specify { expect(asc.to_a).to eq [11, nil, Float::NAN] }
+      specify { expect(desc.to_a).to eq [Float::NAN, nil, 11] }
+    end
+  end
+
   context '#db_type' do
     it 'is DATE for vector with any date in it' do
       # FIXME: is it sane?.. - zverok
@@ -2003,4 +2228,13 @@ describe Daru::Vector do
     end
   end
 
+  context '#where clause when Nan, nil data value is present' do
+    let(:v) { Daru::Vector.new([1,2,3,Float::NAN, nil]) }
+
+    it 'missing/undefined data in Vector/DataFrame' do
+      expect(v.where(v.lt(4))).to eq(Daru::Vector.new([1,2,3]))
+      expect(v.where(v.lt(3))).to eq(Daru::Vector.new([1,2]))
+      expect(v.where(v.lt(2))).to eq(Daru::Vector.new([1]))
+    end
+  end
 end if mri?