daru 0.1.5 → 0.3

data/spec/core/merge_spec.rb

@@ -112,7 +112,7 @@ describe Daru::DataFrame do
       expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
     end
 
-    it "performs a left outer join", focus: true do
+    it "performs a left outer join" do
       answer = Daru::DataFrame.new({
         :id_1 => [2,3,1,4],
         :name => ["Monkey", "Ninja", "Pirate", "Spaghetti"],

data/spec/core/query_spec.rb

@@ -43,79 +43,79 @@ describe "Arel-like syntax" do
           @comparator = Daru::Vector.new([45,22,1214,55,32,9])
           @klass = Daru::Core::Query::BoolArray
         end
-  
+
         context "#eq" do
           it "accepts scalar value" do
             expect(@vector.eq(352)).to eq(
               @klass.new([false,false,false,true,false,false]))
           end
-  
+
           it "accepts vector and compares corrensponding elements" do
             expect(@vector.eq(@comparator)).to eq(
               @klass.new([false,false,true,false,true,false]))
           end
         end
-  
+
         context "#not_eq" do
           it "accepts scalar value" do
             expect(@vector.not_eq(51)).to eq(
               @klass.new([true, false, true, true, true, true]))
           end
-  
+
           it "accepts vector and compares corrensponding elements" do
             expect(@vector.not_eq(@comparator)).to eq(
               @klass.new([true, true, false, true, false, true]))
           end
         end
-  
+
         context "#lt" do
           it "accepts scalar value" do
             expect(@vector.lt(51)).to eq(
               @klass.new([true, false, false, false, true, true]))
           end
-  
+
           it "accepts vector and compares corrensponding elements" do
             expect(@vector.lt(@comparator)).to eq(
               @klass.new([true,false,false,false,false,false]))
           end
         end
-  
+
         context "#lteq" do
           it "accepts scalar value" do
             expect(@vector.lteq(51)).to eq(
               @klass.new([true, true, false, false, true, true]))
           end
-  
+
           it "accepts vector and compares corrensponding elements" do
             expect(@vector.lteq(@comparator)).to eq(
               @klass.new([true,false,true,false,true,false]))
           end
         end
-  
+
         context "#mt" do
           it "accepts scalar value" do
             expect(@vector.mt(51)).to eq(
               @klass.new([false, false, true, true, false, false]))
           end
-  
+
           it "accepts vector and compares corrensponding elements" do
             expect(@vector.mt(@comparator)).to eq(
               @klass.new([false,true,false,true,false,true]))
           end
         end
-  
+
         context "#mteq" do
           it "accepts scalar value" do
             expect(@vector.mteq(51)).to eq(
               @klass.new([false, true, true, true, false, false]))
           end
-  
+
           it "accepts vector and compares corrensponding elements" do
             expect(@vector.mteq(@comparator)).to eq(
               @klass.new([false,true,true,true,true,true]))
           end
         end
-  
+
         context "#in" do
           it "checks if any of elements in the arg are present in the vector" do
             expect(@vector.in([23,55,1,33,32])).to eq(
@@ -123,7 +123,7 @@ describe "Arel-like syntax" do
           end
         end
       end
-      
+
       describe "categorical type" do
         let(:dv) { Daru::Vector.new ['e', 'd', 'd', 'x', 'x'],
           categories: ['a', 'x', 'c', 'd', 'e'], type: :category }
@@ -134,99 +134,99 @@ describe "Arel-like syntax" do
         context "#eq" do
           context "scalar" do
             subject { dv.eq 'd' }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [false, true, true, false, false] }
           end
 
           context "vector" do
             subject { dv.eq comp }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [false, true, false, false, true] }
           end
         end
-  
+
         context "#not_eq" do
           context "scalar" do
             subject { dv.not_eq 'd' }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [true, false, false, true, true] }
           end
-          
+
           context "vector" do
             subject { dv.not_eq comp }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [true, false, true, true, false] }
           end
         end
-  
+
         context "#lt" do
           context "scalar" do
             subject { dv.lt 'd' }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [false, false, false, true, true] }
           end
-          
+
           context "vector" do
             subject { dv.lt comp }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [false, false, false, true, false] }
           end
         end
-  
+
         context "#lteq" do
           context "scalar" do
             subject { dv.lteq 'd' }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [false, true, true, true, true] }
           end
-          
+
           context "vector" do
             subject { dv.lteq comp }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [false, true, false, true, true] }
           end
         end
-  
+
         context "#mt" do
           context "scalar" do
             subject { dv.mt 'd' }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [true, false, false, false, false] }
           end
-          
+
           context "vector" do
             subject { dv.mt comp }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [true, false, true, false, false] }
           end
         end
-  
+
         context "#mteq" do
           context "scalar" do
             subject { dv.mteq 'd' }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [true, true, true, false, false] }
           end
-          
+
           context "vector" do
             subject { dv.mteq comp }
-            
+
             it { is_expected.to be_a query_bool_class }
             its(:to_a) { is_expected.to eq [true, true, true, false, true] }
           end
         end
-  
+
         # context "#in" do
         #   subject { dv.in ['b', 'd'] }
         #   it { is_expected.to be_a query_bool_class }
@@ -240,9 +240,9 @@ describe "Arel-like syntax" do
     context Daru::DataFrame do
       before do
         @df = Daru::DataFrame.new({
-          number: [1,2,3,4,5,6],
-          sym: [:one, :two, :three, :four, :five, :six],
-          names: ['sameer', 'john', 'james', 'omisha', 'priyanka', 'shravan']
+          number: [1,2,3,4,5,6,Float::NAN],
+          sym: [:one, :two, :three, :four, :five, :six, :seven],
+          names: ['sameer', 'john', 'james', 'omisha', 'priyanka', 'shravan',nil]
         })
       end
 
@@ -267,6 +267,11 @@ describe "Arel-like syntax" do
           ).to eq(answer)
       end
 
+      let(:dv) { Daru::Vector.new([1,11,32,Float::NAN,nil]) }
+      it "handles empty data" do
+        expect(dv.where(dv.lt(14))).to eq(Daru::Vector.new([1,11]))
+      end
+
       it "does not give SystemStackError" do
         v = Daru::Vector.new [1]*300_000
         expect { v.where v.eq(1) }.not_to raise_error
@@ -276,45 +281,45 @@ describe "Arel-like syntax" do
     context Daru::Vector do
       context "non-categorical type" do
         before do
-          @vector = Daru::Vector.new([2,5,1,22,51,4])
+          @vector = Daru::Vector.new([2,5,1,22,51,4,nil,Float::NAN])
         end
-  
+
         it "accepts a simple single statement" do
           expect(@vector.where(@vector.lt(10))).to eq(
             Daru::Vector.new([2,5,1,4], index: Daru::Index.new([0,1,2,5])))
         end
-  
+
         it "accepts somewhat complex operator chaining" do
           expect(@vector.where((@vector.lt(6) | @vector.eq(51)))).to eq(
             Daru::Vector.new([2,5,1,51,4], index: Daru::Index.new([0,1,2,4,5])))
         end
       end
-      
+
       context "categorical type" do
         let(:dv) { Daru::Vector.new ['a', 'c', 'x', 'x', 'c'],
           categories: ['a', 'x', 'c'], type: :category }
-        
+
         context "simple single statement" do
           subject { dv.where(dv.lt('x')) }
-          
+
           it { is_expected.to be_a Daru::Vector }
           its(:type) { is_expected.to eq :category }
           its(:to_a) { is_expected.to eq ['a'] }
           its(:'index.to_a') { is_expected.to eq [0] }
         end
-        
+
         context "complex operator chaining" do
           subject { dv.where((dv.lt('x') | dv.eq('c'))) }
-          
+
           it { is_expected.to be_a Daru::Vector }
           its(:type) { is_expected.to eq :category }
           its(:to_a) { is_expected.to eq ['a', 'c', 'c'] }
           its(:'index.to_a') { is_expected.to eq [0, 1, 4] }
         end
-        
+
         context "preserve categories" do
           subject { dv.where((dv.lt('x') | dv.eq('c'))) }
-          
+
           it { is_expected.to be_a Daru::Vector }
           its(:type) { is_expected.to eq :category }
           its(:to_a) { is_expected.to eq ['a', 'c', 'c'] }
@@ -329,4 +334,14 @@ describe "Arel-like syntax" do
       end
     end
   end
+
+  describe "apply_where" do
+    context "matches regexp with block input" do
+      subject { dv.apply_where(dv.match /weeks/) { |x| "#{x.split.first.to_i * 7} days" } }
+
+      let(:dv) { Daru::Vector.new ['3 days', '5 weeks', '2 weeks'] }
+
+      it { is_expected.to eq(Daru::Vector.new ['3 days', '35 days', '14 days']) }
+    end
+  end
 end

data/spec/daru_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe '#error' do
+  context 'by default' do
+    it { expect { Daru.error('test') }.to output("test\n").to_stderr_from_any_process }
+  end
+
+  context 'when set to nil' do
+    before { Daru.error_stream = nil }
+    it { expect { Daru.error('test') }.not_to output('test').to_stderr_from_any_process }
+  end
+
+  context 'when set to instance of custom class' do
+    let(:custom_stream) { double(puts: nil) }
+    before { Daru.error_stream = custom_stream }
+
+    it 'calls puts' do
+      expect { Daru.error('test') }.not_to output('test').to_stderr_from_any_process
+      expect(custom_stream).to have_received(:puts).with('test')
+    end
+  end
+end

data/spec/dataframe_spec.rb

@@ -145,8 +145,15 @@ describe Daru::DataFrame do
   end
 
   context "#initialize" do
+
+    it "initializes an empty DataFrame with no arguments" do
+      df = Daru::DataFrame.new
+      expect(df.nrows).to eq(0)
+      expect(df.ncols).to eq(0)
+    end
+
     context Daru::Index do
-      it "initializes an empty DataFrame" do
+      it "initializes an empty DataFrame with empty source arg" do
         df = Daru::DataFrame.new({}, order: [:a, :b])
 
         expect(df.vectors).to eq(Daru::Index.new [:a, :b])
@@ -164,6 +171,13 @@ describe Daru::DataFrame do
         expect(df.a)      .to eq([1,2,3,4,5].dv(:a, df.index))
       end
 
+      it "initializes from a Hash and preserves default order" do
+        df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]},
+          index: [:one, :two, :three, :four, :five])
+
+        expect(df.vectors).to eq(Daru::Index.new [:b, :a])
+      end
+
       it "initializes from a Hash of Vectors" do
         va = Daru::Vector.new([1,2,3,4,5], index: [:one, :two, :three, :four, :five])
         vb = Daru::Vector.new([11,12,13,14,15], index: [:one, :two, :three, :four, :five])
@@ -221,7 +235,7 @@ describe Daru::DataFrame do
         df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]})
 
         expect(df.index)  .to eq(Daru::Index.new [0,1,2,3,4])
-        expect(df.vectors).to eq(Daru::Index.new [:a, :b])
+        expect(df.vectors).to eq(Daru::Index.new [:b, :a])
       end
 
       it "aligns indexes properly" do
@@ -329,6 +343,14 @@ describe Daru::DataFrame do
         expect(df[:a])         .to eq(Daru::Vector.new([1,2,3,4,5]))
       end
 
+      it "allows creation of dataframe with a default order" do
+        arr_of_arrs_df    = Daru::DataFrame.new([[1,2,3], [4,5,6], [7,8,9]])
+        arr_of_vectors_df = Daru::DataFrame.new([Daru::Vector.new([1,2,3]), Daru::Vector.new([4,5,6]), Daru::Vector.new([7,8,9])])
+
+        expect(arr_of_arrs_df.vectors.to_a).to eq([0,1,2])
+        expect(arr_of_vectors_df.vectors.to_a).to eq([0,1,2])
+      end
+
       it "raises error for incomplete DataFrame index" do
         expect {
           df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
@@ -516,12 +538,31 @@ describe Daru::DataFrame do
           index: [:one, :two, :three, :four, :five]))
       end
 
+      it "assigns new vector with default length if given just a value" do
+        @df[:d] = 1.0
+        expect(@df[:d]).to eq(Daru::Vector.new([1.0, 1.0, 1.0, 1.0, 1.0],
+        index: [:one, :two, :three, :four, :five], name: :d))
+      end
+
+      it "updates vector with default length if given just a value" do
+        @df[:c] = 1.0
+        expect(@df[:c]).to eq(Daru::Vector.new([1.0, 1.0, 1.0, 1.0, 1.0],
+        index: [:one, :two, :three, :four, :five], name: :c))
+      end
+
       it "appends an Array as a Daru::Vector" do
         @df[:d] = [69,99,108,85,49]
 
         expect(@df.d.class).to eq(Daru::Vector)
       end
 
+      it "appends an arbitrary enumerable as a Daru::Vector" do
+        @df[:d] = Set.new([69,99,108,85,49])
+
+        expect(@df[:d]).to eq(Daru::Vector.new([69, 99, 108, 85, 49],
+        index: [:one, :two, :three, :four, :five], name: :c))
+      end
+
       it "replaces an already present vector" do
         @df[:a] = [69,99,108,85,49].dv(nil, [:one, :two, :three, :four, :five])
 
@@ -697,6 +738,47 @@ describe Daru::DataFrame do
     }
   end
 
+  context "#insert_vector" do
+    subject(:data_frame) {
+      Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
+        c: [11,22,33,44,55]}, order: [:a, :b, :c],
+        index: [:one, :two, :three, :four, :five])
+    }
+
+    it "insert a new vector at the desired slot" do
+      df = Daru::DataFrame.new({
+        a: [1,2,3,4,5],
+        d: [710, 720, 730, 740, 750],
+        b: [11, 12, 13, 14, 15],
+        c: [11,22,33,44,55]}, order: [:a, :d, :b, :c],
+        index: [:one, :two, :three, :four, :five]
+      )
+      data_frame.insert_vector 1, :d, [710, 720, 730, 740, 750]
+      expect(subject).to eq df
+    end
+
+    it "raises error for data array being too big" do
+      expect {
+        source = (1..8).to_a
+        data_frame.insert_vector 1, :d, source
+      }.to raise_error(IndexError)
+    end
+
+    it "raises error for invalid index value" do
+      expect {
+        source = (1..5).to_a
+        data_frame.insert_vector 4, :d, source
+      }.to raise_error(ArgumentError)
+    end
+
+    it "raises error for invalid source type" do
+      expect {
+        source = 14
+        data_frame.insert_vector 3, :d, source
+      }.to raise_error(ArgumentError)
+    end
+  end
+
   context "#row[]=" do
     context Daru::Index do
       before :each do
@@ -1546,6 +1628,22 @@ describe Daru::DataFrame do
       }
     end
 
+    context 'with mulitiindex DF' do
+      subject(:data_frame) {
+        Daru::DataFrame.new({b: [11,12,13], a: [1,2,3],
+          c: [11,22,33]}, order: [:a, :b, :c],
+          index: Daru::MultiIndex.from_tuples([[:one, :two], [:one, :three], [:two, :four]]))
+      }
+
+      before { data_frame.add_row [100,200,300], [:two, :five] }
+
+      it { is_expected.to eq(Daru::DataFrame.new({
+          b: [11,12,13,200], a: [1,2,3,100],
+          c: [11,22,33,300]}, order: [:a, :b, :c],
+          index: Daru::MultiIndex.from_tuples([[:one, :two], [:one, :three], [:two, :four], [:two, :five]])))
+      }
+    end
+
     it "allows adding rows after making empty DF by specfying only order" do
       df = Daru::DataFrame.new({}, order: [:a, :b, :c])
       df.add_row [1,2,3]
@@ -1573,6 +1671,13 @@ describe Daru::DataFrame do
     it 'has synonym' do
       expect(@data_frame.first(2)).to eq(@data_frame.head(2))
     end
+
+    it 'works on DateTime indexes' do
+      idx = Daru::DateTimeIndex.new(['2017-01-01', '2017-02-01', '2017-03-01'])
+      df = Daru::DataFrame.new({col1: ['a', 'b', 'c']}, index: idx)
+      first = Daru::DataFrame.new({col1: ['a']}, index: Daru::DateTimeIndex.new(['2017-01-01']))
+      expect(df.head(1)).to eq(first)
+    end
   end
 
   context "#last" do
@@ -1756,6 +1861,59 @@ describe Daru::DataFrame do
     end
   end
 
+  describe 'uniq' do
+    let(:df) do
+      Daru::DataFrame.from_csv 'spec/fixtures/duplicates.csv'
+    end
+
+    context 'with no args' do
+      it do
+        result = df.uniq
+        expect(result.shape.first).to eq 30
+      end
+    end
+
+    context 'given a vector' do
+      it do
+        result = df.uniq("color")
+        expect(result.shape.first).to eq 2
+      end
+    end
+
+    context 'given an array of vectors' do
+      it do
+        result = df.uniq("color", "director_name")
+        expect(result.shape.first).to eq 29
+      end
+    end
+  end
+
+  context '#rolling_fillna!' do
+    subject do
+      Daru::DataFrame.new({
+        a: [1,    2,          3,   nil,        Float::NAN, nil, 1,   7],
+        b: [:a,  :b,          nil, Float::NAN, nil,        3,   5,   nil],
+        c: ['a',  Float::NAN, 3,   4,          3,          5,   nil, 7]
+      })
+    end
+
+    context 'rolling_fillna! forwards' do
+      before { subject.rolling_fillna!(:forward) }
+      it { expect(subject.rolling_fillna!(:forward)).to eq(subject) }
+      its(:'a.to_a') { is_expected.to eq [1, 2, 3, 3, 3, 3, 1, 7] }
+      its(:'b.to_a') { is_expected.to eq [:a,  :b, :b, :b, :b, 3, 5, 5] }
+      its(:'c.to_a') { is_expected.to eq ['a', 'a', 3, 4, 3, 5, 5, 7] }
+    end
+
+    context 'rolling_fillna! backwards' do
+      before { subject.rolling_fillna!(:backward) }
+      it { expect(subject.rolling_fillna!(:backward)).to eq(subject) }
+      its(:'a.to_a') { is_expected.to eq [1, 2, 3, 1, 1, 1, 1, 7] }
+      its(:'b.to_a') { is_expected.to eq [:a, :b, 3, 3, 3, 3, 5, 0] }
+      its(:'c.to_a') { is_expected.to eq ['a', 3, 3, 4, 3, 5, 7, 7] }
+    end
+  end
+
   context "#clone" do
     it "returns a view of the whole dataframe" do
       cloned = @data_frame.clone
@@ -2603,6 +2761,26 @@ describe Daru::DataFrame do
     end
   end
 
+  context "#rename_vectors!" do
+    before do
+      @df = Daru::DataFrame.new({
+        a: [1,2,3,4,5],
+        b: [11,22,33,44,55],
+        c: %w(a b c d e)
+      })
+    end
+
+    it "returns self as modified dataframe" do
+      expect(@df.rename_vectors!(:a => :alpha)).to eq(@df)
+    end
+
+    it "re-uses rename_vectors method" do
+      name_map = { :a => :alpha, :c => :gamma }
+      expect(@df).to receive(:rename_vectors).with(name_map)
+      @df.rename_vectors! name_map
+    end
+  end
+
   context "#rename_vectors" do
     before do
       @df = Daru::DataFrame.new({
@@ -2612,6 +2790,10 @@ describe Daru::DataFrame do
       })
     end
 
+    it "returns Daru::Index" do
+      expect(@df.rename_vectors(:a => :alpha)).to be_kind_of(Daru::Index)
+    end
+
     it "renames vectors using a hash map" do
       @df.rename_vectors :a => :alpha, :c => :gamma
       expect(@df.vectors.to_a).to eq([:alpha, :b, :gamma])
@@ -2667,6 +2849,11 @@ describe Daru::DataFrame do
         :a  => [1,2,3,4,5]
       }, order: [:b, 'a', :a]))
     end
+
+    it 'raises ArgumentError if argument was not an index' do
+      df = Daru::DataFrame.new([])
+      expect { df.reindex_vectors([]) }.to raise_error(ArgumentError)
+    end
   end
 
   context "#to_matrix" do
@@ -3050,9 +3237,34 @@ describe Daru::DataFrame do
   end
 
   context "#summary" do
-    it "produces a summary of data frame" do
-      expect(@data_frame.summary.match("#{@data_frame.name}")).to_not eq(nil)
-      expect(@df_mi.summary.match("#{@df_mi.name}")).to_not eq(nil)
+    subject { df.summary }
+
+    context "DataFrame" do
+      let(:df) { Daru::DataFrame.new({a: [1,2,5], b: [1,2,"string"]}, order: [:a, :b], index: [:one, :two, :three], name: 'frame') }
+      it { is_expected.to eq %Q{
+            |= frame
+            |  Number of rows: 3
+            |  Element:[a]
+            |  == a
+            |    n :3
+            |    non-missing:3
+            |    median: 2
+            |    mean: 2.6667
+            |    std.dev.: 2.0817
+            |    std.err.: 1.2019
+            |    skew: 0.2874
+            |    kurtosis: -2.3333
+            |  Element:[b]
+            |  == b
+            |    n :3
+            |    non-missing:3
+            |    factors: 1,2,string
+            |    mode: 1,2,string
+            |    Distribution
+            |                 1       1 100.00%
+            |                 2       1 100.00%
+            |            string       1 100.00%
+        }.unindent }
     end
   end
 
@@ -3101,6 +3313,15 @@ describe Daru::DataFrame do
       it { expect(subject['a'].to_a).to eq [1, 2, 3] }
       it { expect(subject[:b].to_a).to eq [4, 5, 6] }
     end
+
+    context "preserves indices for dataframes with same index" do
+      let(:index) { ['one','two','three'] }
+      let(:df1) { Daru::DataFrame.new({ 'a' => [1, 2, 3], 'b' => [3, 4, 5] }, index: index) }
+      let(:df2) { Daru::DataFrame.new({ 'c' => [4, 5, 6], 'd' => [7, 8, 9] }, index: index) }
+      subject { df1.merge df2 }
+
+      its(:index) { is_expected.to eq Daru::Index.new(index) }
+    end
   end
 
   context "#vector_by_calculation" do
@@ -3115,25 +3336,41 @@ describe Daru::DataFrame do
     end
   end
 
+  context "group_by" do
+    context "on a single row DataFrame" do
+      let(:df){ Daru::DataFrame.new(city: %w[Kyiv], year: [2015], value: [1]) }
+      it "returns a groupby object" do
+        expect(df.group_by([:city])).to be_a(Daru::Core::GroupBy)
+      end
+      it "has the correct index" do
+        expect(df.group_by([:city]).groups).to eq({["Kyiv"]=>[0]})
+      end
+    end
+  end
+
   context "#vector_sum" do
     before do
-      a1 = Daru::Vector.new [1, 2, 3, 4, 5, nil]
-      a2 = Daru::Vector.new [10, 10, 20, 20, 20, 30]
-      b1 = Daru::Vector.new [nil, 1, 1, 1, 1, 2]
-      b2 = Daru::Vector.new [2, 2, 2, nil, 2, 3]
+      a1 = Daru::Vector.new [1, 2, 3, 4, 5, nil, nil]
+      a2 = Daru::Vector.new [10, 10, 20, 20, 20, 30, nil]
+      b1 = Daru::Vector.new [nil, 1, 1, 1, 1, 2, nil]
+      b2 = Daru::Vector.new [2, 2, 2, nil, 2, 3, nil]
       @df = Daru::DataFrame.new({ :a1 => a1, :a2 => a2, :b1 => b1, :b2 => b2 })
     end
 
     it "calculates complete vector sum" do
-      expect(@df.vector_sum).to eq(Daru::Vector.new [nil, 15, 26, nil, 28, nil])
+      expect(@df.vector_sum).to eq(Daru::Vector.new [nil, 15, 26, nil, 28, nil, nil])
+    end
+
+    it "ignores nils if skipnil is true" do
+      expect(@df.vector_sum skipnil: true).to eq(Daru::Vector.new [13, 15, 26, 25, 28, 35, 0])
     end
 
     it "calculates partial vector sum" do
       a = @df.vector_sum([:a1, :a2])
       b = @df.vector_sum([:b1, :b2])
 
-      expect(a).to eq(Daru::Vector.new [11, 12, 23, 24, 25, nil])
-      expect(b).to eq(Daru::Vector.new [nil, 3, 3, nil, 3, 5])
+      expect(a).to eq(Daru::Vector.new [11, 12, 23, 24, 25, nil, nil])
+      expect(b).to eq(Daru::Vector.new [nil, 3, 3, nil, 3, 5, nil])
     end
   end
 
@@ -3321,7 +3558,8 @@ describe Daru::DataFrame do
       ev_b  = Daru::Vector.new [1, 1, 0]
       ev_c  = Daru::Vector.new [0, 1, 1]
       df2 = Daru::DataFrame.new({
-        :_id => ev_id, 'a' => ev_a, 'b' => ev_b, 'c' => ev_c })
+        :_id => ev_id, 'a' => ev_a, 'b' => ev_b, 'c' => ev_c },
+        order: ['a', 'b', 'c', :_id])
 
       expect(df2).to eq(df)
     end
@@ -3505,6 +3743,41 @@ describe Daru::DataFrame do
     end
   end
 
+  context '#reset_index' do
+    context 'when Index' do
+      subject do
+        Daru::DataFrame.new(
+          {'vals' => [1,2,3,4,5]},
+          index: Daru::Index.new(%w[a b c d e], name: 'indices')
+        ).reset_index
+      end
+
+      it { is_expected.to eq Daru::DataFrame.new(
+        'indices' => %w[a b c d e],
+        'vals' => [1,2,3,4,5]
+      )}
+    end
+
+    context 'when MultiIndex' do
+      subject do
+        mi = Daru::MultiIndex.from_tuples([
+          [0, 'a'], [0, 'b'], [1, 'a'], [1, 'b']
+        ])
+        mi.name = %w[nums alphas]
+        Daru::DataFrame.new(
+          {'vals' => [1,2,3,4]},
+          index: mi
+        ).reset_index
+      end
+
+      it { is_expected.to eq Daru::DataFrame.new(
+        'nums' => [0,0,1,1],
+        'alphas' => %w[a b a b],
+        'vals' => [1,2,3,4]
+      )}
+    end
+  end
+
   context "#set_index" do
     before(:each) do
       @df = Daru::DataFrame.new({
@@ -3544,6 +3817,26 @@ describe Daru::DataFrame do
         jholu.set_index(:a)
       }.to raise_error(ArgumentError)
     end
+
+    it "sets multiindex if array is given" do
+      df = Daru::DataFrame.new({
+        a: %w[a a b b],
+        b: [1, 2, 1, 2],
+        c: %w[a b c d]
+      })
+      df.set_index(%i[a b])
+      expected =
+        Daru::DataFrame.new(
+          { c: %w[a b c d] },
+          index: Daru::MultiIndex.from_tuples(
+            [['a', 1], ['a', 2], ['b', 1], ['b', 2]]
+          )
+        ).tap do |df|
+          df.index.name = %i[a b]
+          df
+        end
+      expect(df).to eq(expected)
+    end
   end
 
   context "#concat" do
@@ -3644,7 +3937,7 @@ describe Daru::DataFrame do
       expect(df_union.index.to_a).to eq v1 + v2
     end
   end
-  
+
   context '#inspect' do
     subject { df.inspect }
 
@@ -3667,6 +3960,41 @@ describe Daru::DataFrame do
        }.unindent}
     end
 
+    context 'if index name is set' do
+      context 'single index with name' do
+        let(:df) { Daru::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]},
+        name: 'test')}
+        before { df.index.name = 'index_name' }
+        it { should == %Q{
+          |#<Daru::DataFrame: test (3x3)>
+          | index_name          a          b          c
+          |          0          1          3          6
+          |          1          2          4          7
+          |          2          3          5          8
+         }.unindent}
+      end
+
+      context 'MultiIndex with name' do
+        let(:mi) { Daru::MultiIndex.new(
+                levels: [[:a,:b,:c], [:one, :two]],
+                labels: [[0,0,1,1,2,2], [0,1,0,1,0,1]], name: ['s1', 's2']) }
+        let(:df) { Daru::DataFrame.new({
+          a: [11, 12, 13, 14, 15, 16], b: [21, 22, 23, 24, 25, 26]},
+            name: 'test', index: mi)}
+        it { should == %Q{
+          |#<Daru::DataFrame: test (6x2)>
+          |  s1  s2   a   b
+          |   a one  11  21
+          |     two  12  22
+          |   b one  13  23
+          |     two  14  24
+          |   c one  15  25
+          |     two  16  26
+         }.unindent}
+      end
+
+    end
+
     context 'no name' do
       let(:df) { Daru::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]})}
       it { should == %Q{
@@ -3709,6 +4037,21 @@ describe Daru::DataFrame do
         |  12   1   1   1
         |  13   1   1   1
         |  14   1   1   1
+        |  15   1   1   1
+        |  16   1   1   1
+        |  17   1   1   1
+        |  18   1   1   1
+        |  19   1   1   1
+        |  20   1   1   1
+        |  21   1   1   1
+        |  22   1   1   1
+        |  23   1   1   1
+        |  24   1   1   1
+        |  25   1   1   1
+        |  26   1   1   1
+        |  27   1   1   1
+        |  28   1   1   1
+        |  29   1   1   1
         | ... ... ... ...
        }.unindent}
     end
@@ -3764,8 +4107,18 @@ describe Daru::DataFrame do
   end
 
   context '#to_s' do
-    it 'produces something, despite of how reasonable you think it is' do
-      expect(@data_frame.to_s).to eq @data_frame.to_html
+    it 'produces a class, size description' do
+      expect(@data_frame.to_s).to eq "#<Daru::DataFrame(5x3)>"
+    end
+
+    it 'produces a class, name, size description' do
+      @data_frame.name = "Test"
+      expect(@data_frame.to_s).to eq "#<Daru::DataFrame: Test(5x3)>"
+    end
+
+    it 'produces a class, name, size description when the name is a symbol' do
+      @data_frame.name = :Test
+      expect(@data_frame.to_s).to eq "#<Daru::DataFrame: Test(5x3)>"
     end
   end
 
@@ -3824,6 +4177,102 @@ describe Daru::DataFrame do
     end
   end
 
+  context '#access_row_tuples_by_indexs' do
+    let(:df) {
+      Daru::DataFrame.new({col: [:a, :b, :c, :d, :e], num: [52,12,07,17,01]}) }
+    let(:df_idx) {
+      Daru::DataFrame.new({a: [52, 12, 07], b: [1, 2, 3]}, index: [:one, :two, :three])
+    }
+    let (:mi_idx) do
+      Daru::MultiIndex.from_tuples [
+        [:a,:one,:bar],
+        [:a,:one,:baz],
+        [:b,:two,:bar],
+        [:a,:two,:baz],
+      ]
+    end
+    let (:df_mi) do
+      Daru::DataFrame.new({
+        a: 1..4,
+        b: 'a'..'d'
+      }, index: mi_idx )
+    end
+    context 'when no index is given' do
+      it 'returns empty Array' do
+        expect(df.access_row_tuples_by_indexs()).to eq([])
+      end
+    end
+    context 'when index(s) are given' do
+      it 'returns Array of row tuples' do
+        expect(df.access_row_tuples_by_indexs(1)).to eq([[:b, 12]])
+        expect(df.access_row_tuples_by_indexs(0,3)).to eq([[:a, 52], [:d, 17]])
+      end
+    end
+    context 'when custom index(s) are given' do
+      it 'returns Array of row tuples' do
+        expect(df_idx.access_row_tuples_by_indexs(:one,:three)).to eq(
+          [[52, 1], [7, 3]]
+        )
+      end
+    end
+    context 'when multi index is given' do
+      it 'returns Array of row tuples' do
+        expect(df_mi.access_row_tuples_by_indexs(:a)).to eq(
+          [[1, "a"], [2, "b"], [4, "d"]]
+        )
+        expect(df_mi.access_row_tuples_by_indexs(:a, :one, :baz)).to eq(
+          [[2, "b"]]
+        )
+      end
+    end
+  end
+
+  context '#aggregate' do
+    let(:cat_idx) { Daru::CategoricalIndex.new [:a, :b, :a, :a, :c] }
+    let(:df) { Daru::DataFrame.new(num: [52,12,07,17,01], cat_index: cat_idx) }
+    let(:df_cat_idx) {
+      Daru::DataFrame.new({num: [52,12,07,17,01]}, index: cat_idx) }
+
+    it 'lambda function on particular column' do
+      expect(df.aggregate(num_100_times: ->(df) { (df.num*100).first })).to eq(
+          Daru::DataFrame.new(num_100_times: [5200, 1200, 700, 1700, 100])
+        )
+    end
+    it 'aggregate sum on particular column' do
+      expect(df_cat_idx.aggregate(num: :sum)).to eq(
+          Daru::DataFrame.new({num: [76, 12, 1]}, index: [:a, :b, :c])
+        )
+    end
+  end
+
+  context '#group_by_and_aggregate' do
+    let(:spending_df) {
+      Daru::DataFrame.rows([
+        [2010,    'dev',  50, 1],
+        [2010,    'dev', 150, 1],
+        [2010,    'dev', 200, 1],
+        [2011,    'dev',  50, 1],
+        [2012,    'dev', 150, 1],
+
+        [2011, 'office', 300, 1],
+
+        [2010, 'market',  50, 1],
+        [2011, 'market', 500, 1],
+        [2012, 'market', 500, 1],
+        [2012, 'market', 300, 1],
+
+        [2012,    'R&D',  10, 1],],
+        order: [:year, :category, :spending, :nb_spending])
+    }
+
+    it 'works as group_by + aggregate' do
+      expect(spending_df.group_by_and_aggregate(:year, {spending: :sum})).to eq(
+        spending_df.group_by(:year).aggregate(spending: :sum))
+      expect(spending_df.group_by_and_aggregate([:year, :category], spending: :sum, nb_spending: :size)).to eq(
+        spending_df.group_by([:year, :category]).aggregate(spending: :sum, nb_spending: :size))
+    end
+  end
+
   context '#create_sql' do
     let(:df) { Daru::DataFrame.new({
         a: [1,2,3],
@@ -3839,4 +4288,12 @@ describe Daru::DataFrame do
       | c DATE) CHARACTER SET=UTF8;
     }.unindent}
   end
+
+  context "#by_single_key" do
+    let(:df) { Daru::DataFrame.new(a: [1, 2, 3], b: [4, 5, 6] ) }
+
+    it 'raise error when vector is missing from dataframe' do
+      expect { df[:c] }.to raise_error(IndexError, /Specified vector c does not exist/)
+    end
+  end
 end if mri?