daru_lite 0.1 → 0.1.2

data/spec/dataframe_spec.rb

@@ -1,9 +1,37 @@
+require 'data_frame/aggregatable_example'
+require 'data_frame/buildable_example'
+require 'data_frame/calculatable_example'
+require 'data_frame/convertible_example'
+require 'data_frame/duplicatable_example'
+require 'data_frame/fetchable_example'
+require 'data_frame/filterable_example'
+require 'data_frame/indexable_example'
+require 'data_frame/iterable_example'
+require 'data_frame/joinable_example'
+require 'data_frame/missable_example'
+require 'data_frame/pivotable_example'
+require 'data_frame/queryable_example'
+require 'data_frame/setable_example'
+require 'data_frame/sortable_example'
+
 describe DaruLite::DataFrame do
-  before :each do
-    @data_frame = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
-      c: [11,22,33,44,55]},
+  let(:df) do
+    DaruLite::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])
+      index: [:one, :two, :three, :four, :five]
+    )
+  end
+  let(:df_mi) do
+    DaruLite::DataFrame.new(
+      [vector_arry1, vector_arry2, vector_arry1, vector_arry2],
+      order: order_mi,
+      index: multi_index
+    )
+  end
+  let(:vector_arry1) { [11,12,13,14,11,12,13,14,11,12,13,14] }
+  let(:vector_arry2) { [1,2,3,4,1,2,3,4,1,2,3,4] }
+  let(:multi_index) do
     tuples = [
       [:a,:one,:bar],
       [:a,:one,:baz],
@@ -18,134 +46,36 @@ describe DaruLite::DataFrame do
       [:c,:two,:foo],
       [:c,:two,:bar]
     ]
-    @multi_index = DaruLite::MultiIndex.from_tuples(tuples)
-
-    @vector_arry1 = [11,12,13,14,11,12,13,14,11,12,13,14]
-    @vector_arry2 = [1,2,3,4,1,2,3,4,1,2,3,4]
-
-    @order_mi = DaruLite::MultiIndex.from_tuples([
-      [:a,:one,:bar],
-      [:a,:two,:baz],
-      [:b,:two,:foo],
-      [:b,:one,:foo]])
-
-    @df_mi = DaruLite::DataFrame.new([
-      @vector_arry1,
-      @vector_arry2,
-      @vector_arry1,
-      @vector_arry2], order: @order_mi, index: @multi_index)
+    DaruLite::MultiIndex.from_tuples(tuples)
   end
-
-  context ".rows" do
-    before do
-      @rows = [
-        [1,2,3,4,5],
-        [1,2,3,4,5],
-        [1,2,3,4,5],
-        [1,2,3,4,5]
+  let(:order_mi) do
+    DaruLite::MultiIndex.from_tuples(
+      [
+        [:a,:one,:bar],
+        [:a,:two,:baz],
+        [:b,:two,:foo],
+        [:b,:one,:foo]
       ]
-    end
-
-    context DaruLite::Index do
-      it "creates a DataFrame from Array rows" do
-        df = DaruLite::DataFrame.rows @rows, order: [:a,:b,:c,:d,:e]
-
-        expect(df.index)      .to eq(DaruLite::Index.new [0,1,2,3])
-        expect(df.vectors)    .to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
-        expect(df[:a]) .to eq(DaruLite::Vector.new [1,1,1,1])
-      end
-
-      it "creates empty dataframe" do
-        df = DaruLite::DataFrame.rows [], order: [:a, :b, :c]
-
-        expect(df.vectors).to eq(DaruLite::Index.new [:a,:b,:c])
-        expect(df.index).to be_empty
-      end
-
-      it "creates a DataFrame from Vector rows" do
-        rows = @rows.map { |r| DaruLite::Vector.new r, index: [:a,:b,:c,:d,:e] }
-
-        df = DaruLite::DataFrame.rows rows, order: [:a,:b,:c,:d,:e]
-
-        expect(df.index)      .to eq(DaruLite::Index.new [0,1,2,3])
-        expect(df.vectors)    .to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
-        expect(df[:a]) .to eq(DaruLite::Vector.new [1,1,1,1])
-      end
-
-      it 'derives index & order from arrays' do
-        df = DaruLite::DataFrame.rows @rows
-        expect(df.index)    .to eq(DaruLite::Index.new [0,1,2,3])
-        expect(df.vectors)  .to eq(DaruLite::Index.new %w[0 1 2 3 4])
-      end
-
-      it 'derives index & order from vectors' do
-        rows = @rows.zip(%w[w x y z]).map { |r, n| DaruLite::Vector.new r, index: [:a,:b,:c,:d,:e], name: n }
-        df = DaruLite::DataFrame.rows rows
-        expect(df.index)    .to eq(DaruLite::Index.new %w[w x y z])
-        expect(df.vectors)  .to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
-      end
-
-      it 'behaves, when rows are repeated' do
-        rows = @rows.zip(%w[w w y z]).map { |r, n| DaruLite::Vector.new r, index: [:a,:b,:c,:d,:e], name: n }
-        df = DaruLite::DataFrame.rows rows
-        expect(df.index)    .to eq(DaruLite::Index.new %w[w_1 w_2 y z])
-        expect(df.vectors)  .to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
-      end
-
-      it 'behaves, when vectors are unnamed' do
-        rows = @rows.map { |r| DaruLite::Vector.new r, index: [:a,:b,:c,:d,:e] }
-        df = DaruLite::DataFrame.rows rows
-        expect(df.index)    .to eq(DaruLite::Index.new [0,1,2,3])
-        expect(df.vectors)  .to eq(DaruLite::Index.new [:a,:b,:c,:d,:e])
-      end
-    end
-
-    context DaruLite::MultiIndex do
-      it "creates a DataFrame from rows" do
-        df = DaruLite::DataFrame.rows(
-          @rows*3, index: @multi_index, order: [:a,:b,:c,:d,:e])
-
-        expect(df.index)     .to eq(@multi_index)
-        expect(df.vectors)   .to eq(DaruLite::Index.new([:a,:b,:c,:d,:e]))
-        expect(df[:a]).to eq(DaruLite::Vector.new([1]*12, index: @multi_index))
-      end
-
-      it "crates a DataFrame from rows (MultiIndex order)" do
-        rows = [
-          [11, 1, 11, 1],
-          [12, 2, 12, 2],
-          [13, 3, 13, 3],
-          [14, 4, 14, 4]
-        ]
-        index = DaruLite::MultiIndex.from_tuples([
-          [:one,:bar],
-          [:one,:baz],
-          [:two,:foo],
-          [:two,:bar]
-        ])
-
-        df = DaruLite::DataFrame.rows(rows, index: index, order: @order_mi)
-        expect(df.index)  .to eq(index)
-        expect(df.vectors).to eq(@order_mi)
-        expect(df[:a, :one, :bar]).to eq(DaruLite::Vector.new([11,12,13,14],
-          index: index))
-      end
-
-      it "creates a DataFrame from Vector rows" do
-        rows = @rows*3
-        rows.map! { |r| DaruLite::Vector.new(r, index: @multi_index) }
-
-        df = DaruLite::DataFrame.rows rows, order: @multi_index
-
-        expect(df.index).to eq(DaruLite::Index.new(Array.new(rows.size) { |i| i }))
-        expect(df.vectors).to eq(@multi_index)
-        expect(df[:a,:one,:bar]).to eq(DaruLite::Vector.new([1]*12))
-      end
-    end
-  end
+    )
+  end
+
+  it_behaves_like 'an aggregatable DataFrame'
+  it_behaves_like 'a buildable DataFrame'
+  it_behaves_like 'a calculatable DataFrame'
+  it_behaves_like 'a convertible DataFrame'
+  it_behaves_like 'a duplicatable DataFrame'
+  it_behaves_like 'a fetchable DataFrame'
+  it_behaves_like 'a filterable DataFrame'
+  it_behaves_like 'an indexable DataFrame'
+  it_behaves_like 'an iterable DataFrame'
+  it_behaves_like 'a joinable DataFrame'
+  it_behaves_like 'a missable DataFrame'
+  it_behaves_like 'a pivotable DataFrame'
+  it_behaves_like 'a queryable DataFrame'
+  it_behaves_like 'a setable DataFrame'
+  it_behaves_like 'a sortable DataFrame'
 
   context "#initialize" do
-
     it "initializes an empty DataFrame with no arguments" do
       df = DaruLite::DataFrame.new
       expect(df.nrows).to eq(0)
@@ -370,24 +300,24 @@ describe DaruLite::DataFrame do
 
     context DaruLite::MultiIndex do
       it "creates empty DataFrame" do
-        df = DaruLite::DataFrame.new({}, order: @order_mi)
+        df = DaruLite::DataFrame.new({}, order: order_mi)
 
-        expect(df.vectors).to eq(@order_mi)
+        expect(df.vectors).to eq(order_mi)
         expect(df[:a, :one, :bar]).to eq(DaruLite::Vector.new([]))
       end
 
       it "creates from Hash" do
         df = DaruLite::DataFrame.new({
-          [:a,:one,:bar] => @vector_arry1,
-          [:a,:two,:baz] => @vector_arry2,
-          [:b,:one,:foo] => @vector_arry1,
-          [:b,:two,:foo] => @vector_arry2
-          }, order: @order_mi, index: @multi_index)
-
-        expect(df.index)               .to eq(@multi_index)
-        expect(df.vectors)             .to eq(@order_mi)
-        expect(df[:a,:one,:bar]).to eq(DaruLite::Vector.new(@vector_arry1,
-          index: @multi_index))
+          [:a,:one,:bar] => vector_arry1,
+          [:a,:two,:baz] => vector_arry2,
+          [:b,:one,:foo] => vector_arry1,
+          [:b,:two,:foo] => vector_arry2
+          }, order: order_mi, index: multi_index)
+
+        expect(df.index)               .to eq(multi_index)
+        expect(df.vectors)             .to eq(order_mi)
+        expect(df[:a,:one,:bar]).to eq(DaruLite::Vector.new(vector_arry1,
+          index: multi_index))
       end
 
       it "creates from Array of Hashes" do
@@ -395,25 +325,25 @@ describe DaruLite::DataFrame do
       end
 
       it "creates from Array of Arrays" do
-        df = DaruLite::DataFrame.new([@vector_arry1, @vector_arry2, @vector_arry1,
-          @vector_arry2], index: @multi_index, order: @order_mi)
+        df = DaruLite::DataFrame.new([vector_arry1, vector_arry2, vector_arry1,
+          vector_arry2], index: multi_index, order: order_mi)
 
-        expect(df.index)  .to eq(@multi_index)
-        expect(df.vectors).to eq(@order_mi)
-        expect(df[:a, :one, :bar]).to eq(DaruLite::Vector.new(@vector_arry1,
-          index: @multi_index))
+        expect(df.index)  .to eq(multi_index)
+        expect(df.vectors).to eq(order_mi)
+        expect(df[:a, :one, :bar]).to eq(DaruLite::Vector.new(vector_arry1,
+          index: multi_index))
       end
 
       it "raises error for order MultiIndex of different size than supplied Array" do
         expect {
-          df = DaruLite::DataFrame.new([@vector_arry1, @vector_arry2], order: @order_mi,
-            index: @multi_index)
+          df = DaruLite::DataFrame.new([vector_arry1, vector_arry2], order: order_mi,
+            index: multi_index)
         }.to raise_error
       end
 
       it "aligns MultiIndexes properly" do
         pending
-        mi_a = @order_mi
+        mi_a = order_mi
         mi_b = DaruLite::MultiIndex.from_tuples([
           [:b,:one,:foo],
           [:a,:one,:bar],
@@ -450,215 +380,6 @@ describe DaruLite::DataFrame do
     end
   end
 
-  context "#[]" do
-    context DaruLite::Index do
-      before :each do
-        @df = DaruLite::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])
-      end
-
-      it "returns a Vector" do
-        expect(@df[:a]).to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
-      end
-
-      it "returns a Vector by default" do
-        expect(@df[:a]).to eq(DaruLite::Vector.new([1,2,3,4,5], name: :a,
-          index: [:one, :two, :three, :four, :five]))
-      end
-
-      it "returns a DataFrame" do
-        temp = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]},
-          order: [:a, :b], index: [:one, :two, :three, :four, :five])
-
-        expect(@df[:a, :b]).to eq(temp)
-      end
-
-      it "accesses vector with Integer index" do
-        expect(@df[0]).to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
-      end
-
-      it "returns a subset of DataFrame when specified range" do
-        subset = @df[:b..:c]
-        expect(subset).to eq(DaruLite::DataFrame.new({
-          b: [11,12,13,14,15],
-          c: [11,22,33,44,55]
-          }, index: [:one, :two, :three, :four, :five]))
-      end
-
-      it 'accepts axis parameter as a last argument' do
-        expect(@df[:a, :vector]).to eq @df[:a]
-        expect(@df[:one, :row]).to eq [1, 11, 11].dv(:one, [:a, :b, :c])
-      end
-    end
-
-    context DaruLite::MultiIndex do
-      it "accesses vector with an integer index" do
-        expect(@df_mi[0]).to eq(
-          DaruLite::Vector.new(@vector_arry1, index: @multi_index))
-      end
-
-      it "returns a vector when specifying full tuple" do
-        expect(@df_mi[:a, :one, :bar]).to eq(
-          DaruLite::Vector.new(@vector_arry1, index: @multi_index))
-      end
-
-      it "returns DataFrame when specified first layer of MultiIndex" do
-        sub_order = DaruLite::MultiIndex.from_tuples([
-          [:one, :bar],
-          [:two, :baz]
-          ])
-        expect(@df_mi[:a]).to eq(DaruLite::DataFrame.new([
-          @vector_arry1,
-          @vector_arry2
-        ], index: @multi_index, order: sub_order))
-      end
-
-      it "returns a Vector if the last level of MultiIndex is tracked" do
-        expect(@df_mi[:a, :one, :bar]).to eq(
-          DaruLite::Vector.new(@vector_arry1, index: @multi_index))
-      end
-    end
-  end
-
-  context "#[]=" do
-    context DaruLite::Index do
-      before :each do
-        @df = DaruLite::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])
-      end
-
-      it "assigns directly with the []= operator" do
-        @data_frame[:a] = [100,200,300,400,500]
-        expect(@data_frame).to eq(DaruLite::DataFrame.new({
-          b: [11,12,13,14,15],
-          a: [100,200,300,400,500],
-          c: [11,22,33,44,55]}, order: [:a, :b, :c],
-          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(DaruLite::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(DaruLite::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 DaruLite::Vector" do
-        @df[:d] = [69,99,108,85,49]
-
-        expect(@df.d.class).to eq(DaruLite::Vector)
-      end
-
-      it "appends an arbitrary enumerable as a DaruLite::Vector" do
-        @df[:d] = Set.new([69,99,108,85,49])
-
-        expect(@df[:d]).to eq(DaruLite::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])
-
-        expect(@df.a).to eq([69,99,108,85,49].dv(nil, [:one, :two, :three, :four, :five]))
-      end
-
-      it "appends a new vector to the DataFrame" do
-        @df[:woo] = [69,99,108,85,49].dv(nil, [:one, :two, :three, :four, :five])
-
-        expect(@df.vectors).to eq([:a, :b, :c, :woo].to_index)
-      end
-
-      it "creates an index for the new vector if not specified" do
-        @df[:woo] = [69,99,108,85,49]
-
-        expect(@df.woo.index).to eq([:one, :two, :three, :four, :five].to_index)
-      end
-
-      it "matches index of vector to be inserted with the DataFrame index" do
-        @df[:shankar] = [69,99,108,85,49].dv(:shankar, [:two, :one, :three, :five, :four])
-
-        expect(@df.shankar).to eq([99,69,108,49,85].dv(:shankar,
-          [:one, :two, :three, :four, :five]))
-      end
-
-      it "matches index of vector to be inserted, inserting nils where no match found" do
-        @df[:shankar] = [1,2,3].dv(:shankar, [:one, :james, :hetfield])
-
-        expect(@df.shankar).to eq([1,nil,nil,nil,nil].dv(:shankar, [:one, :two, :three, :four, :five]))
-      end
-
-      it "raises error for Array assignment of wrong length" do
-        expect{
-          @df[:shiva] = [1,2,3]
-          }.to raise_error
-      end
-
-      it "assigns correct name given empty dataframe" do
-        df_empty = DaruLite::DataFrame.new({})
-        df_empty[:a] = 1..5
-        df_empty[:b] = 1..5
-
-        expect(df_empty[:a].name).to equal(:a)
-        expect(df_empty[:b].name).to equal(:b)
-      end
-
-      it "appends multiple vectors at a time" do
-        # TODO
-      end
-    end
-
-    context DaruLite::MultiIndex do
-      it "raises error when incomplete index specified but index is absent" do
-        expect {
-          @df_mi[:d] = [100,200,300,400,100,200,300,400,100,200,300,400]
-        }.to raise_error
-      end
-
-      it "assigns all sub-indexes when a top level index is specified" do
-        @df_mi[:a] = [100,200,300,400,100,200,300,400,100,200,300,400]
-
-        expect(@df_mi).to eq(DaruLite::DataFrame.new([
-          [100,200,300,400,100,200,300,400,100,200,300,400],
-          [100,200,300,400,100,200,300,400,100,200,300,400],
-          @vector_arry1,
-          @vector_arry2], index: @multi_index, order: @order_mi))
-      end
-
-      it "creates a new vector when full index specfied" do
-        order = DaruLite::MultiIndex.from_tuples([
-          [:a,:one,:bar],
-          [:a,:two,:baz],
-          [:b,:two,:foo],
-          [:b,:one,:foo],
-          [:c,:one,:bar]])
-        answer = DaruLite::DataFrame.new([
-          @vector_arry1,
-          @vector_arry2,
-          @vector_arry1,
-          @vector_arry2,
-          [100,200,300,400,100,200,300,400,100,200,300,400]
-          ], index: @multi_index, order: order)
-        @df_mi[:c,:one,:bar] = [100,200,300,400,100,200,300,400,100,200,300,400]
-
-        expect(@df_mi).to eq(answer)
-      end
-
-      it "assigns correct name given empty dataframe" do
-        df_empty = DaruLite::DataFrame.new([], index: @multi_index, order: @order_mi)
-        df_empty[:c, :one, :bar] = 1..12
-
-        expect(df_empty[:c, :one, :bar].name).to eq "conebar"
-      end
-    end
-  end
-
   context '#method_missing' do
     let(:df) { DaruLite::DataFrame.new({
       :a  => [1, 2, 3, 4, 5],
@@ -720,197 +441,6 @@ describe DaruLite::DataFrame do
     end
   end
 
-  context '#add_vector' do
-    subject(:data_frame) {
-      DaruLite::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])
-    }
-    before {
-      data_frame.add_vector :a, [100,200,300,400,500]
-    }
-
-    it { is_expected.to eq(DaruLite::DataFrame.new({
-          b: [11,12,13,14,15],
-          a: [100,200,300,400,500],
-          c: [11,22,33,44,55]}, order: [:a, :b, :c],
-          index: [:one, :two, :three, :four, :five]))
-    }
-  end
-
-  context "#insert_vector" do
-    subject(:data_frame) {
-      DaruLite::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 = DaruLite::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 DaruLite::Index do
-      before :each do
-        @df = DaruLite::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])
-      end
-
-      it "assigns specified row when Array" do
-        @df.row[:one] = [49, 99, 59]
-
-        expect(@df.row[:one])      .to eq([49, 99, 59].dv(:one, [:a, :b, :c]))
-        expect(@df.row[:one].index).to eq([:a, :b, :c].to_index)
-        expect(@df.row[:one].name) .to eq(:one)
-      end
-
-      it "assigns specified row when DV" do
-        @df.row[:one] = [49, 99, 59].dv(nil, [:a, :b, :c])
-
-        expect(@df.row[:one]).to eq([49, 99, 59].dv(:one, [:a, :b, :c]))
-      end
-
-      it "assigns correct elements when Vector of different index" do
-        @df.row[:one] = DaruLite::Vector.new([44,62,11], index: [:b,:f,:a])
-
-        expect(@df.row[:one]).to eq(DaruLite::Vector.new([11,44,nil], index: [:a,:b,:c]))
-      end
-
-      it "creates a new row from an Array" do
-        @df.row[:patekar] = [9,2,11]
-
-        expect(@df.row[:patekar]).to eq([9,2,11].dv(:patekar, [:a, :b, :c]))
-      end
-
-      it "creates a new row from a DV" do
-        @df.row[:patekar] = [9,2,11].dv(nil, [:a, :b, :c])
-
-        expect(@df.row[:patekar]).to eq([9,2,11].dv(:patekar, [:a, :b, :c]))
-      end
-
-      it "creates a new row from numeric row index and named DV" do
-        @df.row[2] = [9,2,11].dv(nil, [:a, :b, :c])
-
-        expect(@df.row[2]).to eq([9,2,11].dv(nil, [:a, :b, :c]))
-      end
-
-      it "correctly aligns assigned DV by index" do
-        @df.row[:two] = [9,2,11].dv(nil, [:b, :a, :c])
-
-        expect(@df.row[:two]).to eq([2,9,11].dv(:two, [:a, :b, :c]))
-      end
-
-      it "correctlu aligns assinged DV by index for new rows" do
-        @df.row[:latest] = DaruLite::Vector.new([2,3,1], index: [:b,:c,:a])
-
-        expect(@df.row[:latest]).to eq(DaruLite::Vector.new([1,2,3], index: [:a,:b,:c]))
-      end
-
-      it "inserts nils for indexes that dont exist in the DataFrame" do
-        @df.row[:two] = [49, 99, 59].dv(nil, [:oo, :aah, :gaah])
-
-        expect(@df.row[:two]).to eq([nil,nil,nil].dv(nil, [:a, :b, :c]))
-      end
-
-      it "correctly inserts row of a different length by matching indexes" do
-        @df.row[:four] = [5,4,3,2,1,3].dv(nil, [:you, :have, :a, :big, :appetite, :spock])
-
-        expect(@df.row[:four]).to eq([3,nil,nil].dv(:four, [:a, :b, :c]))
-      end
-
-      it "raises error for row insertion by Array of wrong length" do
-        expect{
-          @df.row[:one] = [1,2,3,4,5,6,7]
-        }.to raise_error
-      end
-    end
-
-    context DaruLite::MultiIndex do
-      pending
-      # TO DO
-    end
-
-    context DaruLite::CategoricalIndex do
-      let(:idx) { DaruLite::CategoricalIndex.new [:a, 1, :a, 1, :c] }
-      let(:df) do
-        DaruLite::DataFrame.new({
-          a: 'a'..'e',
-          b: 1..5
-        }, index: idx)
-      end
-
-      context "modify exiting row" do
-        context "single category" do
-          subject { df }
-          before { df.row[:a] = ['x', 'y'] }
-
-          it { is_expected.to be_a DaruLite::DataFrame }
-          its(:index) { is_expected.to eq idx }
-          its(:vectors) { is_expected.to eq DaruLite::Index.new [:a, :b] }
-          its(:'a.to_a') { is_expected.to eq ['x', 'b', 'x', 'd', 'e'] }
-          its(:'b.to_a') { is_expected.to eq ['y', 2, 'y', 4, 5] }
-        end
-
-        context "multiple categories" do
-          subject { df }
-          before { df.row[:a, 1] = ['x', 'y'] }
-
-          it { is_expected.to be_a DaruLite::DataFrame }
-          its(:index) { is_expected.to eq idx }
-          its(:vectors) { is_expected.to eq DaruLite::Index.new [:a, :b] }
-          its(:'a.to_a') { is_expected.to eq ['x', 'x', 'x', 'x', 'e'] }
-          its(:'b.to_a') { is_expected.to eq ['y', 'y', 'y', 'y', 5] }
-        end
-
-        context "positional index" do
-          subject { df }
-          before { df.row[0, 2] = ['x', 'y'] }
-
-          it { is_expected.to be_a DaruLite::DataFrame }
-          its(:index) { is_expected.to eq idx }
-          its(:vectors) { is_expected.to eq DaruLite::Index.new [:a, :b] }
-          its(:'a.to_a') { is_expected.to eq ['x', 'b', 'x', 'd', 'e'] }
-          its(:'b.to_a') { is_expected.to eq ['y', 2, 'y', 4, 5] }
-        end
-      end
-
-      context "add new row" do
-        # TODO
-      end
-    end
-  end
-
   context "#row.at" do
     context DaruLite::Index do
       let(:idx) { DaruLite::Index.new [1, 0, :c] }
@@ -1139,311 +669,21 @@ describe DaruLite::DataFrame do
     end
   end
 
-  context "#row.set_at" do
-    let(:df) do
-      DaruLite::DataFrame.new({
-        a: 1..3,
-        b: 'a'..'c'
-      })
-    end
+  context "#row[]" do
+    context DaruLite::Index do
+      before :each do
+        @df = DaruLite::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])
+      end
 
-    context "single position" do
-      subject { df }
-      before { df.row.set_at [1], ['x', 'y'] }
+      it "creates an index for assignment if not already specified" do
+        @df.row[:one] = [49, 99, 59]
 
-      its(:size) { is_expected.to eq 3 }
-      its(:'a.to_a') { is_expected.to eq [1, 'x', 3] }
-      its(:'b.to_a') { is_expected.to eq ['a', 'y', 'c'] }
-    end
-
-    context "multiple position" do
-      subject { df }
-      before { df.row.set_at [0, 2], ['x', 'y'] }
-
-      its(:size) { is_expected.to eq 3 }
-      its(:'a.to_a') { is_expected.to eq ['x', 2, 'x'] }
-      its(:'b.to_a') { is_expected.to eq ['y', 'b', 'y'] }
-    end
-
-    context "invalid position" do
-      it { expect { df.row.set_at [3], ['x', 'y'] }.to raise_error IndexError }
-    end
-
-    context "invalid positions" do
-      it { expect { df.row.set_at [2, 3], ['x', 'y'] }.to raise_error IndexError }
-    end
-
-    context "incorrect size" do
-      it { expect { df.row.set_at [1], ['x', 'y', 'z'] }.to raise_error SizeError }
-    end
-  end
-
-  context "#at" do
-    context DaruLite::Index do
-      let(:idx) { DaruLite::Index.new [:a, :b, :c] }
-      let(:df) do
-        DaruLite::DataFrame.new({
-          1 => 1..3,
-          a: 'a'..'c',
-          b: 11..13
-        }, index: idx)
-      end
-
-      context "single position" do
-        subject { df.at 1 }
-
-        it { is_expected.to be_a DaruLite::Vector }
-        its(:size) { is_expected.to eq 3 }
-        its(:to_a) { is_expected.to eq ['a', 'b', 'c'] }
-        its(:index) { is_expected.to eq idx }
-      end
-
-      context "multiple positions" do
-        subject { df.at 0, 2 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 2] }
-        its(:index) { is_expected.to eq idx }
-        it { expect(df[1].to_a).to eq [1, 2, 3] }
-        its(:'b.to_a') { is_expected.to eq [11, 12, 13] }
-      end
-
-      context "single invalid position" do
-        it { expect { df. at 3 }.to raise_error IndexError }
-      end
-
-      context "multiple invalid positions" do
-        it { expect { df.at 2, 3 }.to raise_error IndexError }
-      end
-
-      context "range" do
-        subject { df.at 0..1 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 2] }
-        its(:index) { is_expected.to eq idx }
-        it { expect(df[1].to_a).to eq [1, 2, 3] }
-        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
-      end
-
-      context "range with negative end" do
-        subject { df.at 0..-2 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 2] }
-        its(:index) { is_expected.to eq idx }
-        it { expect(df[1].to_a).to eq [1, 2, 3] }
-        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
-      end
-
-      context "range with single element" do
-        subject { df.at 1..1 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 1] }
-        its(:index) { is_expected.to eq idx }
-        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
-      end
-    end
-
-    context DaruLite::MultiIndex do
-      let (:idx) do
-        DaruLite::MultiIndex.from_tuples [
-          [:a,:one,:bar],
-          [:a,:one,:baz],
-          [:b,:two,:bar],
-        ]
-      end
-      let(:df) do
-        DaruLite::DataFrame.new({
-          1 => 1..3,
-          a: 'a'..'c',
-          b: 11..13
-        }, index: idx)
-      end
-
-      context "single position" do
-        subject { df.at 1 }
-
-        it { is_expected.to be_a DaruLite::Vector }
-        its(:size) { is_expected.to eq 3 }
-        its(:to_a) { is_expected.to eq ['a', 'b', 'c'] }
-        its(:index) { is_expected.to eq idx }
-      end
-
-      context "multiple positions" do
-        subject { df.at 0, 2 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 2] }
-        its(:index) { is_expected.to eq idx }
-        it { expect(df[1].to_a).to eq [1, 2, 3] }
-        its(:'b.to_a') { is_expected.to eq [11, 12, 13] }
-      end
-
-      context "single invalid position" do
-        it { expect { df. at 3 }.to raise_error IndexError }
-      end
-
-      context "multiple invalid positions" do
-        it { expect { df.at 2, 3 }.to raise_error IndexError }
-      end
-
-      context "range" do
-        subject { df.at 0..1 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 2] }
-        its(:index) { is_expected.to eq idx }
-        it { expect(df[1].to_a).to eq [1, 2, 3] }
-        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
-      end
-
-      context "range with negative end" do
-        subject { df.at 0..-2 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 2] }
-        its(:index) { is_expected.to eq idx }
-        it { expect(df[1].to_a).to eq [1, 2, 3] }
-        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
-      end
-
-      context "range with single element" do
-        subject { df.at 1..1 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 1] }
-        its(:index) { is_expected.to eq idx }
-        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
-      end
-    end
-
-    context DaruLite::CategoricalIndex do
-      let (:idx) { DaruLite::CategoricalIndex.new [:a, 1, 1] }
-      let(:df) do
-        DaruLite::DataFrame.new({
-          1 => 1..3,
-          a: 'a'..'c',
-          b: 11..13
-        }, index: idx)
-      end
-
-      context "single position" do
-        subject { df.at 1 }
-
-        it { is_expected.to be_a DaruLite::Vector }
-        its(:size) { is_expected.to eq 3 }
-        its(:to_a) { is_expected.to eq ['a', 'b', 'c'] }
-        its(:index) { is_expected.to eq idx }
-      end
-
-      context "multiple positions" do
-        subject { df.at 0, 2 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 2] }
-        its(:index) { is_expected.to eq idx }
-        it { expect(df[1].to_a).to eq [1, 2, 3] }
-        its(:'b.to_a') { is_expected.to eq [11, 12, 13] }
-      end
-
-      context "single invalid position" do
-        it { expect { df. at 3 }.to raise_error IndexError }
-      end
-
-      context "multiple invalid positions" do
-        it { expect { df.at 2, 3 }.to raise_error IndexError }
-      end
-
-      context "range" do
-        subject { df.at 0..1 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 2] }
-        its(:index) { is_expected.to eq idx }
-        it { expect(df[1].to_a).to eq [1, 2, 3] }
-        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
-      end
-
-      context "range with negative index" do
-        subject { df.at 0..-2 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 2] }
-        its(:index) { is_expected.to eq idx }
-        it { expect(df[1].to_a).to eq [1, 2, 3] }
-        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
-      end
-
-      context "range with single element" do
-        subject { df.at 1..1 }
-
-        it { is_expected.to be_a DaruLite::DataFrame }
-        its(:shape) { is_expected.to eq [3, 1] }
-        its(:index) { is_expected.to eq idx }
-        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
-      end
-    end
-  end
-
-  context "#set_at" do
-    let(:df) do
-      DaruLite::DataFrame.new({
-        1 => 1..3,
-        a: 'a'..'c',
-        b: 11..13
-      })
-    end
-
-    context "single position" do
-      subject { df }
-      before { df.set_at [1], ['x', 'y', 'z'] }
-
-      its(:shape) { is_expected.to eq [3, 3] }
-      it { expect(df[1].to_a).to eq [1, 2, 3] }
-      its(:'a.to_a') { is_expected.to eq ['x', 'y', 'z'] }
-      its(:'b.to_a') { is_expected.to eq [11, 12, 13] }
-    end
-
-    context "multiple position" do
-      subject { df }
-      before { df.set_at [1, 2], ['x', 'y', 'z'] }
-
-      its(:shape) { is_expected.to eq [3, 3] }
-      it { expect(df[1].to_a).to eq [1, 2, 3] }
-      its(:'a.to_a') { is_expected.to eq ['x', 'y', 'z'] }
-      its(:'b.to_a') { is_expected.to eq ['x', 'y', 'z'] }
-    end
-
-    context "invalid position" do
-      it { expect { df.set_at [3], ['x', 'y', 'z'] }.to raise_error IndexError }
-    end
-
-    context "invalid positions" do
-      it { expect { df.set_at [2, 3], ['x', 'y', 'z'] }.to raise_error IndexError }
-    end
-
-    context "incorrect size" do
-      it { expect { df.set_at [1], ['x', 'y'] }.to raise_error SizeError }
-    end
-  end
-
-  context "#row[]" do
-    context DaruLite::Index do
-      before :each do
-        @df = DaruLite::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])
-      end
-
-      it "creates an index for assignment if not already specified" do
-        @df.row[:one] = [49, 99, 59]
-
-        expect(@df[:one, :row])      .to eq([49, 99, 59].dv(:one, [:a, :b, :c]))
-        expect(@df[:one, :row].index).to eq([:a, :b, :c].to_index)
-        expect(@df[:one, :row].name) .to eq(:one)
-      end
+        expect(@df[:one, :row])      .to eq([49, 99, 59].dv(:one, [:a, :b, :c]))
+        expect(@df[:one, :row].index).to eq([:a, :b, :c].to_index)
+        expect(@df[:one, :row].name) .to eq(:one)
+      end
 
       it "returns a DataFrame when specifying numeric Range" do
         expect(@df.row[0..2]).to eq(
@@ -1488,7 +728,7 @@ describe DaruLite::DataFrame do
 
     context DaruLite::MultiIndex do
       it "returns a Vector when specifying integer index" do
-        expect(@df_mi.row[0]).to eq(DaruLite::Vector.new([11,1,11,1], index: @order_mi))
+        expect(df_mi.row[0]).to eq(DaruLite::Vector.new([11,1,11,1], index: order_mi))
       end
 
       it "returns a DataFrame whecn specifying numeric range" do
@@ -1497,16 +737,16 @@ describe DaruLite::DataFrame do
           [:a,:one,:baz]
         ])
 
-        expect(@df_mi.row[0..1]).to eq(DaruLite::DataFrame.new([
+        expect(df_mi.row[0..1]).to eq(DaruLite::DataFrame.new([
           [11,12],
           [1,2],
           [11,12],
           [1,2]
-        ], order: @order_mi, index: sub_index, name: :numeric_range))
+        ], order: order_mi, index: sub_index, name: :numeric_range))
       end
 
       it "returns a Vector when specifying complete tuple" do
-        expect(@df_mi.row[:c,:two,:foo]).to eq(DaruLite::Vector.new([13,3,13,3], index: @order_mi))
+        expect(df_mi.row[:c,:two,:foo]).to eq(DaruLite::Vector.new([13,3,13,3], index: order_mi))
       end
 
       it "returns DataFrame when specifying first layer of MultiIndex" do
@@ -1516,12 +756,12 @@ describe DaruLite::DataFrame do
           [:two,:foo],
           [:two,:bar]
         ])
-        expect(@df_mi.row[:c]).to eq(DaruLite::DataFrame.new([
+        expect(df_mi.row[:c]).to eq(DaruLite::DataFrame.new([
           [11,12,13,14],
           [1,2,3,4],
           [11,12,13,14],
           [1,2,3,4]
-          ], index: sub_index, order: @order_mi))
+          ], index: sub_index, order: order_mi))
       end
 
       it "returns DataFrame when specifying first and second layer of MultiIndex" do
@@ -1529,12 +769,12 @@ describe DaruLite::DataFrame do
           [:bar],
           [:baz]
         ])
-        expect(@df_mi.row[:c,:one]).to eq(DaruLite::DataFrame.new([
+        expect(df_mi.row[:c,:one]).to eq(DaruLite::DataFrame.new([
           [11,12],
           [1,2],
           [11,12],
           [1,2]
-        ], index: sub_index, order: @order_mi))
+        ], index: sub_index, order: order_mi))
       end
     end
 
@@ -1596,107 +836,6 @@ describe DaruLite::DataFrame do
     end
   end
 
-  context "#add_row" do
-    subject(:data_frame) {
-      DaruLite::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])
-    }
-    context 'named' do
-      before {
-        data_frame.add_row [100,200,300], :six
-      }
-
-      it { is_expected.to eq(DaruLite::DataFrame.new({
-            a: [1,2,3,4,5,100],
-            b: [11,12,13,14,15,200],
-            c: [11,22,33,44,55,300]}, order: [:a, :b, :c],
-            index: [:one, :two, :three, :four, :five, :six]))
-      }
-    end
-
-    context 'unnamed' do
-      before {
-        data_frame.add_row [100,200,300]
-      }
-
-      it { is_expected.to eq(DaruLite::DataFrame.new({
-            a: [1,2,3,4,5,100],
-            b: [11,12,13,14,15,200],
-            c: [11,22,33,44,55,300]}, order: [:a, :b, :c],
-            index: [:one, :two, :three, :four, :five, 5]))
-      }
-    end
-
-    context 'with mulitiindex DF' do
-      subject(:data_frame) {
-        DaruLite::DataFrame.new({b: [11,12,13], a: [1,2,3],
-          c: [11,22,33]}, order: [:a, :b, :c],
-          index: DaruLite::MultiIndex.from_tuples([[:one, :two], [:one, :three], [:two, :four]]))
-      }
-
-      before { data_frame.add_row [100,200,300], [:two, :five] }
-
-      it { is_expected.to eq(DaruLite::DataFrame.new({
-          b: [11,12,13,200], a: [1,2,3,100],
-          c: [11,22,33,300]}, order: [:a, :b, :c],
-          index: DaruLite::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 = DaruLite::DataFrame.new({}, order: [:a, :b, :c])
-      df.add_row [1,2,3]
-      df.add_row [5,6,7]
-
-      expect(df[:a]).to eq(DaruLite::Vector.new([1,5]))
-      expect(df[:b]).to eq(DaruLite::Vector.new([2,6]))
-      expect(df[:c]).to eq(DaruLite::Vector.new([3,7]))
-      expect(df.index).to eq(DaruLite::Index.new([0,1]))
-    end
-  end
-
-  context "#first" do
-    it 'works' do
-      expect(@data_frame.first(2)).to eq(
-        DaruLite::DataFrame.new({b: [11,12], a: [1,2], c: [11,22]},
-        order: [:a, :b, :c],
-        index: [:one, :two]))
-    end
-
-    it 'works with too large values' do
-      expect(@data_frame.first(200)).to eq(@data_frame)
-    end
-
-    it 'has synonym' do
-      expect(@data_frame.first(2)).to eq(@data_frame.head(2))
-    end
-
-    it 'works on DateTime indexes' do
-      idx = DaruLite::DateTimeIndex.new(['2017-01-01', '2017-02-01', '2017-03-01'])
-      df = DaruLite::DataFrame.new({col1: ['a', 'b', 'c']}, index: idx)
-      first = DaruLite::DataFrame.new({col1: ['a']}, index: DaruLite::DateTimeIndex.new(['2017-01-01']))
-      expect(df.head(1)).to eq(first)
-    end
-  end
-
-  context "#last" do
-    it 'works' do
-      expect(@data_frame.last(2)).to eq(
-        DaruLite::DataFrame.new({b: [14,15], a: [4,5], c: [44,55]},
-        order: [:a, :b, :c],
-        index: [:four, :five]))
-    end
-
-    it 'works with too large values' do
-      expect(@data_frame.last(200)).to eq(@data_frame)
-    end
-
-    it 'has synonym' do
-      expect(@data_frame.last(2)).to eq(@data_frame.tail(2))
-    end
-  end
-
   context "#==" do
     it "compares by vectors, index and values of a DataFrame (ignores name)" do
       a = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]},
@@ -1710,1083 +849,81 @@ describe DaruLite::DataFrame do
   end
 
   context '#rename' do
-    subject { @data_frame.rename 'other' }
+    subject { df.rename 'other' }
 
     it { is_expected.to be_a DaruLite::DataFrame }
     its(:name) { is_expected.to eq 'other' }
   end
 
-  context "#dup" do
+  context "#delete_vector" do
     context DaruLite::Index do
-      it "dups every data structure inside DataFrame" do
-        clo = @data_frame.dup
-
-        expect(clo.object_id)        .not_to eq(@data_frame.object_id)
-        expect(clo.vectors.object_id).not_to eq(@data_frame.vectors.object_id)
-        expect(clo.index.object_id)  .not_to eq(@data_frame.index.object_id)
+      it "deletes the specified vector" do
+        df.delete_vector :a
 
-        @data_frame.each_vector_with_index do |vector, index|
-          expect(vector.object_id).not_to eq(clo[index].object_id)
-          expect(vector.to_a.object_id).not_to eq(clo[index].to_a.object_id)
-        end
+        expect(df).to eq(DaruLite::DataFrame.new({b: [11,12,13,14,15],
+                c: [11,22,33,44,55]}, order: [:b, :c],
+                index: [:one, :two, :three, :four, :five]))
       end
     end
+  end
 
-    context DaruLite::MultiIndex do
-      it "duplicates with multi index" do
-        clo = @df_mi.dup
+  context "#delete_vectors" do
+    context DaruLite::Index do
+      it "deletes the specified vectors" do
+        df.delete_vectors :a, :b
 
-        expect(clo)                  .to     eq(@df_mi)
-        expect(clo.vectors.object_id).not_to eq(@df_mi.vectors.object_id)
-        expect(clo.index.object_id)  .not_to eq(@df_mi.index.object_id)
+        expect(df).to eq(DaruLite::DataFrame.new({
+                c: [11,22,33,44,55]}, order: [:c],
+                index: [:one, :two, :three, :four, :five]))
       end
     end
   end
 
-  context '#reject_values' do
-    let(:df) do
-      DaruLite::DataFrame.new({
-        a: [1,    2,          3,   nil,        Float::NAN, nil, 1,   7],
-        b: [:a,  :b,          nil, Float::NAN, nil,        3,   5,   8],
-        c: ['a',  Float::NAN, 3,   4,          3,          5,   nil, 7]
-      }, index: 11..18)
-    end
-    before { df.to_category :b }
-
-    context 'remove nils only' do
-      subject { df.reject_values nil }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [1, 2, 7] }
-      its(:'b.to_a') { is_expected.to eq [:a, :b, 8] }
-      its(:'c.to_a') { is_expected.to eq ['a', Float::NAN, 7] }
-      its(:'index.to_a') { is_expected.to eq [11, 12, 18] }
-    end
-
-    context 'remove Float::NAN only' do
-      subject { df.reject_values Float::NAN }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [1, 3, nil, 1, 7] }
-      its(:'b.to_a') { is_expected.to eq [:a, nil, 3, 5, 8] }
-      its(:'c.to_a') { is_expected.to eq ['a', 3, 5, nil, 7] }
-      its(:'index.to_a') { is_expected.to eq [11, 13, 16, 17, 18] }
-    end
+  context "#delete_row" do
+    it "deletes the specified row" do
+      df.delete_row :three
 
-    context 'remove both nil and Float::NAN' do
-      subject { df.reject_values nil, Float::NAN }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [1, 7] }
-      its(:'b.to_a') { is_expected.to eq [:a, 8] }
-      its(:'c.to_a') { is_expected.to eq ['a', 7] }
-      its(:'index.to_a') { is_expected.to eq [11, 18] }
+      expect(df).to eq(DaruLite::DataFrame.new({b: [11,12,14,15], a: [1,2,4,5],
+      c: [11,22,44,55]}, order: [:a, :b, :c], index: [:one, :two, :four, :five]))
     end
+  end
 
-    context 'any other values' do
-      subject { df.reject_values 1, 5 }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [2, 3, nil, Float::NAN, 7] }
-      its(:'b.to_a') { is_expected.to eq [:b, nil, Float::NAN, nil, 8] }
-      its(:'c.to_a') { is_expected.to eq [Float::NAN, 3, 4, 3, 7] }
-      its(:'index.to_a') { is_expected.to eq [12, 13, 14, 15, 18] }
+  context "#rename_vectors!" do
+    before do
+      @df = DaruLite::DataFrame.new({
+        a: [1,2,3,4,5],
+        b: [11,22,33,44,55],
+        c: %w(a b c d e)
+      })
     end
 
-    context 'when resultant dataframe has one row' do
-      subject { df.reject_values 1, 2, 3, 4, 5, nil, Float::NAN }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [7] }
-      its(:'b.to_a') { is_expected.to eq [8] }
-      its(:'c.to_a') { is_expected.to eq [7] }
-      its(:'index.to_a') { is_expected.to eq [18] }
+    it "returns self as modified dataframe" do
+      expect(@df.rename_vectors!(:a => :alpha)).to eq(@df)
     end
 
-    context 'when resultant dataframe is empty' do
-      subject { df.reject_values 1, 2, 3, 4, 5, 6, 7, nil, Float::NAN }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [] }
-      its(:'b.to_a') { is_expected.to eq [] }
-      its(:'c.to_a') { is_expected.to eq [] }
-      its(:'index.to_a') { is_expected.to eq [] }
+    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 '#replace_values' do
-    subject do
-      DaruLite::DataFrame.new({
-        a: [1,    2,          3,   nil,        Float::NAN, nil, 1,   7],
-        b: [:a,  :b,          nil, Float::NAN, nil,        3,   5,   8],
-        c: ['a',  Float::NAN, 3,   4,          3,          5,   nil, 7]
+  context "#rename_vectors" do
+    before do
+      @df = DaruLite::DataFrame.new({
+        a: [1,2,3,4,5],
+        b: [11,22,33,44,55],
+        c: %w(a b c d e)
       })
     end
-    before { subject.to_category :b }
 
-    context 'replace nils only' do
-      before { subject.replace_values nil, 10 }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [1, 2, 3, 10, Float::NAN, 10, 1, 7] }
-      its(:'b.to_a') { is_expected.to eq [:a,  :b, 10, Float::NAN, 10, 3, 5, 8] }
-      its(:'c.to_a') { is_expected.to eq ['a', Float::NAN, 3, 4, 3, 5, 10, 7] }
+    it "returns DaruLite::Index" do
+      expect(@df.rename_vectors(:a => :alpha)).to be_kind_of(DaruLite::Index)
     end
 
-    context 'replace Float::NAN only' do
-      before { subject.replace_values Float::NAN, 10 }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [1, 2, 3, nil, 10, nil, 1, 7] }
-      its(:'b.to_a') { is_expected.to eq [:a,  :b, nil, 10, nil, 3, 5, 8] }
-      its(:'c.to_a') { is_expected.to eq ['a', 10, 3, 4, 3, 5, nil, 7] }
-    end
-
-    context 'replace both nil and Float::NAN' do
-      before { subject.replace_values [nil, Float::NAN], 10 }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [1, 2, 3, 10, 10, 10, 1, 7] }
-      its(:'b.to_a') { is_expected.to eq [:a,  :b, 10, 10, 10, 3, 5, 8] }
-      its(:'c.to_a') { is_expected.to eq ['a', 10, 3, 4, 3, 5, 10, 7] }
-    end
-
-    context 'replace other values' do
-      before { subject.replace_values [1, 5], 10 }
-      it { is_expected.to be_a DaruLite::DataFrame }
-      its(:'b.type') { is_expected.to eq :category }
-      its(:'a.to_a') { is_expected.to eq [10, 2, 3, nil, Float::NAN, nil, 10, 7] }
-      its(:'b.to_a') { is_expected.to eq [:a,  :b, nil, Float::NAN, nil, 3, 10, 8] }
-      its(:'c.to_a') { is_expected.to eq ['a', Float::NAN, 3, 4, 3, 10, nil, 7] }
-    end
-  end
-
-  describe 'uniq' do
-    let(:df) do
-      DaruLite::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
-      DaruLite::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
-      expect(@data_frame.object_id).to_not eq(cloned.object_id)
-      expect(@data_frame[:a].object_id).to eq(cloned[:a].object_id)
-      expect(@data_frame[:b].object_id).to eq(cloned[:b].object_id)
-      expect(@data_frame[:c].object_id).to eq(cloned[:c].object_id)
-    end
-
-    it "returns a view of selected vectors" do
-      cloned = @data_frame.clone(:a, :b)
-      expect(cloned.object_id).to_not eq(@data_frame.object_id)
-      expect(cloned[:a].object_id).to eq(@data_frame[:a].object_id)
-      expect(cloned[:b].object_id).to eq(@data_frame[:b].object_id)
-    end
-
-    it "clones properly when supplied array" do
-      cloned = @data_frame.clone([:a, :b])
-      expect(cloned.object_id).to_not eq(@data_frame.object_id)
-      expect(cloned[:a].object_id).to eq(@data_frame[:a].object_id)
-      expect(cloned[:b].object_id).to eq(@data_frame[:b].object_id)
-    end
-
-    it "original dataframe remains unaffected when operations are applied
-      on cloned data frame" do
-      original = @data_frame.dup
-      cloned = @data_frame.clone
-      cloned.delete_vector :a
-
-      expect(@data_frame).to eq(original)
-    end
-
-  end
-
-  context "#clone_only_valid" do
-    let(:df_with_missing) {
-      DaruLite::DataFrame.new({
-        a: [1  , 2, 3, nil, 4, nil, 5],
-        b: [nil, 2, 3, nil, 4, nil, 5],
-        c: [1,   2, 3, 43 , 4, nil, 5]
-      })
-    }
-
-    let(:df_without_missing) {
-      DaruLite::DataFrame.new({
-        a: [2,3,4,5],
-        c: [2,3,4,5]
-      })
-    }
-    it 'does the most reasonable thing' do
-      expect(df_with_missing.clone_only_valid).to eq(df_with_missing.reject_values(*DaruLite::MISSING_VALUES))
-      expect(df_without_missing.clone_only_valid).to eq(df_without_missing.clone)
-    end
-  end
-
-  context "#clone_structure" do
-    it "clones only the index and vector structures of the data frame" do
-      cs = @data_frame.clone_structure
-
-      expect(cs.vectors).to eq(@data_frame.vectors)
-      expect(cs.index).to eq(@data_frame.index)
-      expect(cs[:a]).to eq(DaruLite::Vector.new([nil] * cs[:a].size, index: @data_frame.index))
-    end
-  end
-
-  context "#each_index" do
-    it "iterates over index" do
-      idxs = []
-      ret = @data_frame.each_index do |index|
-        idxs << index
-      end
-
-      expect(idxs).to eq([:one, :two, :three, :four, :five])
-
-      expect(ret).to eq(@data_frame)
-    end
-  end
-
-  context "#each_vector_with_index" do
-    it "iterates over vectors with index" do
-      idxs = []
-      ret = @data_frame.each_vector_with_index do |vector, index|
-        idxs << index
-        expect(vector.index).to eq([:one, :two, :three, :four, :five].to_index)
-        expect(vector.class).to eq(DaruLite::Vector)
-      end
-
-      expect(idxs).to eq([:a, :b, :c])
-
-      expect(ret).to eq(@data_frame)
-    end
-  end
-
-  context "#each_row_with_index" do
-    it "iterates over rows with indexes" do
-      idxs = []
-      ret = @data_frame.each_row_with_index do |row, idx|
-        idxs << idx
-        expect(row.index).to eq([:a, :b, :c].to_index)
-        expect(row.class).to eq(DaruLite::Vector)
-      end
-
-      expect(idxs).to eq([:one, :two, :three, :four, :five])
-      expect(ret) .to eq(@data_frame)
-    end
-  end
-
-  context "#each" do
-    it "iterates over rows" do
-      ret = @data_frame.each(:row) do |row|
-        expect(row.index).to eq([:a, :b, :c].to_index)
-        expect(row.class).to eq(DaruLite::Vector)
-      end
-
-      expect(ret).to eq(@data_frame)
-    end
-
-    it "iterates over all vectors" do
-      ret = @data_frame.each do |vector|
-        expect(vector.index).to eq([:one, :two, :three, :four, :five].to_index)
-        expect(vector.class).to eq(DaruLite::Vector)
-      end
-
-      expect(ret).to eq(@data_frame)
-    end
-
-    it "returns Enumerable if no block specified" do
-      ret = @data_frame.each
-      expect(ret.is_a?(Enumerator)).to eq(true)
-    end
-
-    it "raises on unknown axis" do
-      expect { @data_frame.each(:kitten) }.to raise_error(ArgumentError, /axis/)
-    end
-  end
-
-  context "#recode" do
-    before do
-      @ans_vector = DaruLite::DataFrame.new({b: [21,22,23,24,25], a: [11,12,13,14,15],
-        c: [21,32,43,54,65]}, order: [:a, :b, :c],
-        index: [:one, :two, :three, :four, :five])
-
-      @ans_rows = DaruLite::DataFrame.new({b: [121, 144, 169, 196, 225], a: [1,4,9,16,25],
-        c: [121, 484, 1089, 1936, 3025]}, order: [:a, :b, :c],
-        index: [:one, :two, :three, :four, :five])
-
-      @data_frame_date_time = @data_frame.dup
-      @data_frame_date_time.index = DaruLite::DateTimeIndex.date_range(start:"2016-02-11", periods:5)
-
-      @ans_vector_date_time = DaruLite::DataFrame.new({b: [21,22,23,24,25], a: [11,12,13,14,15],
-        c: [21,32,43,54,65]}, order: [:a, :b, :c],
-        index: DaruLite::DateTimeIndex.date_range(start:"2016-02-11", periods:5))
-
-      @ans_rows_date_time = DaruLite::DataFrame.new({b: [121, 144, 169, 196, 225], a: [1,4,9,16,25],
-        c: [121, 484, 1089, 1936, 3025]}, order: [:a, :b, :c],
-        index: DaruLite::DateTimeIndex.date_range(start:"2016-02-11", periods:5))
-    end
-
-    it "maps over the vectors of a DataFrame and returns a DataFrame" do
-      ret = @data_frame.recode do |vector|
-        vector.map! { |e| e += 10}
-      end
-
-      expect(ret).to eq(@ans_vector)
-    end
-
-    it "maps over the rows of a DataFrame and returns a DataFrame" do
-      ret = @data_frame.recode(:row) do |row|
-        expect(row.class).to eq(DaruLite::Vector)
-        row.map! { |e| e*e }
-      end
-
-      expect(ret).to eq(@ans_rows)
-    end
-
-    it "maps over the vectors of a DataFrame with DateTimeIndex and returns a DataFrame with DateTimeIndex" do
-      ret = @data_frame_date_time.recode do |vector|
-        vector.map! { |e| e += 10}
-      end
-
-      expect(ret).to eq(@ans_vector_date_time)
-    end
-
-    it "maps over the rows of a DataFrame with DateTimeIndex and returns a DataFrame with DateTimeIndex" do
-      ret = @data_frame_date_time.recode(:row) do |row|
-        expect(row.class).to eq(DaruLite::Vector)
-        row.map! { |e| e*e }
-      end
-
-      expect(ret).to eq(@ans_rows_date_time)
-    end
-
-  end
-
-  context "#collect" do
-    before do
-      @df = DaruLite::DataFrame.new({
-        a: [1,2,3,4,5],
-        b: [11,22,33,44,55],
-        c: [1,2,3,4,5]
-      })
-    end
-
-    it "collects calculation over rows and returns a Vector from the results" do
-      expect(@df.collect(:row) { |row| (row[:a] + row[:c]) * row[:c] }).to eq(
-        DaruLite::Vector.new([2,8,18,32,50])
-        )
-    end
-
-    it "collects calculation over vectors and returns a Vector from the results" do
-      expect(@df.collect { |v| v[0] * v[1] + v[4] }).to eq(
-        DaruLite::Vector.new([7,297,7], index: [:a, :b, :c])
-        )
-    end
-  end
-
-  context "#map" do
-    it "iterates over rows and returns an Array" do
-      ret = @data_frame.map(:row) do |row|
-        expect(row.class).to eq(DaruLite::Vector)
-        row[:a] * row[:c]
-      end
-
-      expect(ret).to eq([11, 44, 99, 176, 275])
-      expect(@data_frame.vectors.to_a).to eq([:a, :b, :c])
-    end
-
-    it "iterates over vectors and returns an Array" do
-      ret = @data_frame.map do |vector|
-        vector.mean
-      end
-      expect(ret).to eq([3.0, 13.0, 33.0])
-    end
-  end
-
-  context "#map!" do
-    before do
-      @ans_vector = DaruLite::DataFrame.new({b: [21,22,23,24,25], a: [11,12,13,14,15],
-        c: [21,32,43,54,65]}, order: [:a, :b, :c],
-        index: [:one, :two, :three, :four, :five])
-
-      @ans_row = DaruLite::DataFrame.new({b: [12,13,14,15,16], a: [2,3,4,5,6],
-        c: [12,23,34,45,56]}, order: [:a, :b, :c],
-        index: [:one, :two, :three, :four, :five])
-    end
-
-    it "destructively maps over the vectors and changes the DF" do
-      @data_frame.map! do |vector|
-        vector + 10
-      end
-      expect(@data_frame).to eq(@ans_vector)
-    end
-
-    it "destructively maps over the rows and changes the DF" do
-      @data_frame.map!(:row) do |row|
-        row + 1
-      end
-
-      expect(@data_frame).to eq(@ans_row)
-    end
-  end
-
-  context "#map_vectors_with_index" do
-    it "iterates over vectors with index and returns an Array" do
-      idx = []
-      ret = @data_frame.map_vectors_with_index do |vector, index|
-        idx << index
-        vector.recode { |e| e += 10}
-      end
-
-      expect(ret).to eq([
-        DaruLite::Vector.new([11,12,13,14,15],index: [:one, :two, :three, :four, :five]),
-        DaruLite::Vector.new([21,22,23,24,25],index: [:one, :two, :three, :four, :five]),
-        DaruLite::Vector.new([21,32,43,54,65],index: [:one, :two, :three, :four, :five])])
-      expect(idx).to eq([:a, :b, :c])
-    end
-  end
-
-  # FIXME: collect_VECTORS_with_index, but map_VECTOR_with_index -- ??? -- zverok
-  # (Not saying about unfortunate difference between them...)
-  context "#collect_vector_with_index" do
-    it "iterates over vectors with index and returns an Array" do
-      idx = []
-      ret = @data_frame.collect_vector_with_index do |vector, index|
-        idx << index
-        vector.sum
-      end
-
-      expect(ret).to eq(DaruLite::Vector.new([15, 65, 165], index: [:a, :b, :c]))
-      expect(idx).to eq([:a, :b, :c])
-    end
-  end
-
-  context "#map_rows_with_index" do
-    it "iterates over rows with index and returns an Array" do
-      idx = []
-      ret = @data_frame.map_rows_with_index do |row, index|
-        idx << index
-        expect(row.class).to eq(DaruLite::Vector)
-        row[:a] * row[:c]
-      end
-
-      expect(ret).to eq([11, 44, 99, 176, 275])
-      expect(idx).to eq([:one, :two, :three, :four, :five])
-    end
-  end
-
-  context '#collect_row_with_index' do
-    it "iterates over rows with index and returns a Vector" do
-      idx = []
-      ret = @data_frame.collect_row_with_index do |row, index|
-        idx << index
-        expect(row.class).to eq(DaruLite::Vector)
-        row[:a] * row[:c]
-      end
-
-      expected = DaruLite::Vector.new([11, 44, 99, 176, 275], index: @data_frame.index)
-      expect(ret).to eq(expected)
-      expect(idx).to eq([:one, :two, :three, :four, :five])
-    end
-  end
-
-  context "#delete_vector" do
-    context DaruLite::Index do
-      it "deletes the specified vector" do
-        @data_frame.delete_vector :a
-
-        expect(@data_frame).to eq(DaruLite::DataFrame.new({b: [11,12,13,14,15],
-                c: [11,22,33,44,55]}, order: [:b, :c],
-                index: [:one, :two, :three, :four, :five]))
-      end
-    end
-  end
-
-  context "#delete_vectors" do
-    context DaruLite::Index do
-      it "deletes the specified vectors" do
-        @data_frame.delete_vectors :a, :b
-
-        expect(@data_frame).to eq(DaruLite::DataFrame.new({
-                c: [11,22,33,44,55]}, order: [:c],
-                index: [:one, :two, :three, :four, :five]))
-      end
-    end
-  end
-
-  context "#delete_row" do
-    it "deletes the specified row" do
-      @data_frame.delete_row :three
-
-      expect(@data_frame).to eq(DaruLite::DataFrame.new({b: [11,12,14,15], a: [1,2,4,5],
-      c: [11,22,44,55]}, order: [:a, :b, :c], index: [:one, :two, :four, :five]))
-    end
-  end
-
-  context "#keep_row_if" do
-    pending "changing row from under the iterator trips this"
-    it "keeps row if block evaluates to true" do
-      df = DaruLite::DataFrame.new({b: [10,12,20,23,30], a: [50,30,30,1,5],
-        c: [10,20,30,40,50]}, order: [:a, :b, :c],
-        index: [:one, :two, :three, :four, :five])
-
-      df.keep_row_if do |row|
-        row[:a] % 10 == 0
-      end
-      # TODO: write expectation
-    end
-  end
-
-  context "#keep_vector_if" do
-    it "keeps vector if block evaluates to true" do
-      @data_frame.keep_vector_if do |vector|
-        vector == [1,2,3,4,5].dv(nil, [:one, :two, :three, :four, :five])
-      end
-
-      expect(@data_frame).to eq(DaruLite::DataFrame.new({a: [1,2,3,4,5]}, order: [:a],
-        index: [:one, :two, :three, :four, :five]))
-    end
-  end
-
-  context "#filter_field" do
-    before do
-      @df = DaruLite::DataFrame.new({
-        :id => DaruLite::Vector.new([1, 2, 3, 4, 5]),
-        :name => DaruLite::Vector.new(%w(Alex Claude Peter Franz George)),
-        :age => DaruLite::Vector.new([20, 23, 25, 27, 5]),
-        :city => DaruLite::Vector.new(['New York', 'London', 'London', 'Paris', 'Tome']),
-        :a1 => DaruLite::Vector.new(['a,b', 'b,c', 'a', nil, 'a,b,c']) },
-        order: [:id, :name, :age, :city, :a1])
-    end
-
-    it "creates new vector with the data of a given field for which block returns true" do
-      filtered = @df.filter_vector(:id) { |c| c[:id] == 2 or c[:id] == 4 }
-      expect(filtered).to eq(DaruLite::Vector.new([2,4]))
-    end
-  end
-
-  context "#filter_rows" do
-    context DaruLite::Index do
-      context "when specified no index" do
-        it "filters rows" do
-          df = DaruLite::DataFrame.new({a: [1,2,3], b: [2,3,4]})
-
-          a = df.filter_rows do |row|
-            row[:a] % 2 == 0
-          end
-
-          expect(a).to eq(DaruLite::DataFrame.new({a: [2], b: [3]}, order: [:a, :b], index: [1]))
-        end
-      end
-
-      context "when specified numerical index" do
-        it "filters rows" do
-          df = DaruLite::DataFrame.new({a: [1,2,3], b: [2,3,4]}, index: [1,2,3])
-
-          a = df.filter_rows do |row|
-            row[:a] % 2 == 0
-          end
-
-          expect(a).to eq(DaruLite::DataFrame.new({a: [2], b: [3]}, order: [:a, :b], index: [2]))
-        end
-      end
-
-      it "preserves names of vectors" do
-        df = DaruLite::DataFrame.new a: 1..3, b: 4..6
-        df1 = df.filter_rows { |r| r[:a] != 2 }
-
-        expect(df1[:a].name).to eq(df[:a].name)
-      end
-    end
-  end
-
-  context "#filter_vectors" do
-    context DaruLite::Index do
-      it "filters vectors" do
-        df = DaruLite::DataFrame.new({a: [1,2,3], b: [2,3,4]})
-
-        a = df.filter_vectors do |vector|
-          vector[0] == 1
-        end
-
-        expect(a).to eq(DaruLite::DataFrame.new({a: [1,2,3]}))
-      end
-    end
-  end
-
-  context "#filter" do
-    let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [2,3,4]}) }
-    it "dispatches" do
-      expect(df.filter(:row){|r| r[:a] % 2 == 0 }).to \
-        eq df.filter_rows{|r| r[:a] % 2 == 0 }
-
-      expect(df.filter(:vector){|v| v[0] == 1}).to \
-        eq df.filter_vectors{|v| v[0] == 1}
-
-      expect { df.filter(:kitten){} }.to raise_error ArgumentError, /axis/
-    end
-  end
-
-  context "#to_a" do
-    context DaruLite::Index do
-      it "converts DataFrame into array of hashes" do
-        arry = @data_frame.to_a
-
-        expect(arry).to eq(
-          [
-            [
-              {a: 1, b: 11, c: 11},
-              {a: 2, b: 12, c: 22},
-              {a: 3, b: 13, c: 33},
-              {a: 4, b: 14, c: 44},
-              {a: 5, b: 15, c: 55}
-            ],
-            [
-              :one, :two, :three, :four, :five
-            ]
-          ])
-      end
-    end
-
-    context DaruLite::MultiIndex do
-      pending
-    end
-  end
-
-  context "#to_h" do
-    it "converts to a hash" do
-      expect(@data_frame.to_h).to eq(
-        {
-          a: DaruLite::Vector.new([1,2,3,4,5],
-            index: [:one, :two, :three, :four, :five]),
-          b: DaruLite::Vector.new([11,12,13,14,15],
-            index: [:one, :two, :three, :four, :five]),
-          c: DaruLite::Vector.new([11,22,33,44,55],
-            index: [:one, :two, :three, :four, :five])
-        }
-      )
-    end
-  end
-
-  context "#sort" do
-    context DaruLite::Index do
-      before :each do
-        @df = DaruLite::DataFrame.new({a: [5,1,-6,7,5,5], b: [-2,-1,5,3,9,1], c: ['a','aa','aaa','aaaa','aaaaa','aaaaaa']})
-      end
-
-      it "sorts according to given vector order (bang)" do
-        a_sorter = lambda { |a| a }
-        ans = @df.sort([:a], by: { a: a_sorter })
-
-        expect(ans).to eq(
-          DaruLite::DataFrame.new({a: [-6,1,5,5,5,7], b: [5,-1,-2,9,1,3], c: ['aaa','aa','a','aaaaa','aaaaaa','aaaa']},
-            index: [2,1,0,4,5,3])
-          )
-        expect(ans).to_not eq(@df)
-      end
-
-      it "sorts according to vector order using default lambdas (index re ordered according to the last vector) (bang)" do
-        ans = @df.sort([:a, :b])
-        expect(ans).to eq(
-          DaruLite::DataFrame.new({a: [-6,1,5,5,5,7], b: [5,-1,-2,1,9,3], c: ['aaa','aa','a','aaaaaa','aaaaa','aaaa']},
-            index: [2,1,0,5,4,3])
-          )
-        expect(ans).to_not eq(@df)
-      end
-    end
-
-    context DaruLite::MultiIndex do
-      pending
-    end
-
-    context DaruLite::CategoricalIndex do
-      let(:idx) { DaruLite::CategoricalIndex.new [:a, 1, :a, 1, :c] }
-      let(:df) do
-        DaruLite::DataFrame.new({
-          a: [2, -1, 3, 4, 5],
-          b: ['x', 'y', 'x', 'a', 'y'],
-          c: [nil, nil, -2, 2, 1]
-        }, index: idx)
-      end
-
-      context "ascending order" do
-        context "single vector" do
-          subject { df.sort [:a] }
-
-          its(:'index.to_a') { is_expected.to eq [1, :a, :a, 1, :c] }
-          its(:'a.to_a') { is_expected.to eq [-1, 2, 3, 4, 5] }
-          its(:'b.to_a') { is_expected.to eq ['y', 'x', 'x', 'a', 'y'] }
-          its(:'c.to_a') { is_expected.to eq [nil, nil, -2, 2, 1] }
-        end
-
-        context "multiple vectors" do
-          subject { df.sort [:c, :b] }
-
-          its(:'index.to_a') { is_expected.to eq [:a, 1, :a, :c, 1] }
-          its(:'a.to_a') { is_expected.to eq [2, -1, 3, 5, 4] }
-          its(:'b.to_a') { is_expected.to eq ['x', 'y', 'x', 'y', 'a'] }
-          its(:'c.to_a') { is_expected.to eq [nil, nil, -2, 1, 2] }
-        end
-
-        context "block" do
-          context "automatic handle nils" do
-            subject do
-              df.sort [:c], by: {c: lambda { |a| a.abs } }, handle_nils: true
-            end
-
-            its(:'index.to_a') { is_expected.to eq [:a, 1, :c, :a, 1] }
-            its(:'a.to_a') { is_expected.to eq [2, -1, 5, 3, 4] }
-            its(:'b.to_a') { is_expected.to eq ['x', 'y', 'y', 'x', 'a'] }
-            its(:'c.to_a') { is_expected.to eq [nil, nil, 1, -2, 2] }
-          end
-
-          context "manually handle nils" do
-            subject do
-              df.sort [:c], by: {c: lambda { |a| (a.nil?)?[1]:[0,a.abs] } }
-            end
-
-            its(:'index.to_a') { is_expected.to eq [:c, :a, 1, :a, 1] }
-            its(:'a.to_a') { is_expected.to eq [5, 3, 4, 2, -1] }
-            its(:'b.to_a') { is_expected.to eq ['y', 'x', 'a', 'x', 'y'] }
-            its(:'c.to_a') { is_expected.to eq [1, -2, 2, nil, nil] }
-          end
-        end
-      end
-
-      context "descending order" do
-        context "single vector" do
-          subject { df.sort [:a], ascending: false }
-
-          its(:'index.to_a') { is_expected.to eq [:c, 1, :a, :a, 1] }
-          its(:'a.to_a') { is_expected.to eq [5, 4, 3, 2, -1] }
-          its(:'b.to_a') { is_expected.to eq ['y', 'a', 'x', 'x', 'y'] }
-          its(:'c.to_a') { is_expected.to eq [1, 2, -2, nil, nil] }
-        end
-
-        context "multiple vectors" do
-          subject { df.sort [:c, :b], ascending: false }
-
-          its(:'index.to_a') { is_expected.to eq [1, :a, 1, :c, :a] }
-          its(:'a.to_a') { is_expected.to eq [-1, 2, 4, 5, 3] }
-          its(:'b.to_a') { is_expected.to eq ['y', 'x', 'a', 'y', 'x'] }
-          its(:'c.to_a') { is_expected.to eq [nil, nil, 2, 1, -2] }
-        end
-
-        context "block" do
-          context "automatic handle nils" do
-            subject do
-              df.sort [:c],
-                by: {c: lambda { |a| a.abs } },
-                handle_nils: true,
-                ascending: false
-            end
-
-            its(:'index.to_a') { is_expected.to eq [:a, 1, :a, 1, :c] }
-            its(:'a.to_a') { is_expected.to eq [2, -1, 3, 4, 5] }
-            its(:'b.to_a') { is_expected.to eq ['x', 'y', 'x', 'a', 'y'] }
-            its(:'c.to_a') { is_expected.to eq [nil, nil, -2, 2, 1] }
-          end
-
-          context "manually handle nils" do
-            subject do
-              df.sort [:c],
-                by: {c: lambda { |a| (a.nil?)?[1]:[0,a.abs] } },
-                ascending: false
-            end
-
-            its(:'index.to_a') { is_expected.to eq [:a, 1, :a, 1, :c] }
-            its(:'a.to_a') { is_expected.to eq [2, -1, 3, 4, 5] }
-            its(:'b.to_a') { is_expected.to eq ['x', 'y', 'x', 'a', 'y'] }
-            its(:'c.to_a') { is_expected.to eq [nil, nil, -2, 2, 1] }
-          end
-        end
-      end
-    end
-  end
-
-  context "#sort!" do
-    context DaruLite::Index do
-      before :each do
-        @df = DaruLite::DataFrame.new({a: [5,1,-6,7,5,5], b: [-2,-1,5,3,9,1],
-          c: ['a','aa','aaa','aaaa','aaaaa','aaaaaa']})
-      end
-
-      it "sorts according to given vector order (bang)" do
-        a_sorter = lambda { |a| a }
-
-        expect(@df.sort!([:a], by: { a: a_sorter })).to eq(
-          DaruLite::DataFrame.new({a: [-6,1,5,5,5,7], b: [5,-1,-2,9,1,3],
-            c: ['aaa','aa','a','aaaaa','aaaaaa','aaaa']}, index: [2,1,0,4,5,3])
-          )
-      end
-
-      it "sorts according to vector order using default lambdas (index re ordered according to the last vector) (bang)" do
-        expect(@df.sort!([:a, :b])).to eq(
-          DaruLite::DataFrame.new({a: [-6,1,5,5,5,7], b: [5,-1,-2,1,9,3], c: ['aaa','aa','a','aaaaaa','aaaaa','aaaa']},
-            index: [2,1,0,5,4,3])
-          )
-      end
-
-      it "sorts both vectors in descending order" do
-        expect(@df.sort!([:a,:b], ascending: [false, false])).to eq(
-          DaruLite::DataFrame.new({a: [7,5,5,5,1,-6], b: [3,9,1,-2,-1,5], c: ['aaaa','aaaaa','aaaaaa', 'a','aa', 'aaa'] },
-            index: [3,4,5,0,1,2])
-          )
-      end
-
-      it "sorts one vector in desc and other is asc" do
-        expect(@df.sort!([:a, :b], ascending: [false, true])).to eq(
-          DaruLite::DataFrame.new({a: [7,5,5,5,1,-6], b: [3,-2,1,9,-1,5], c: ['aaaa','a','aaaaaa','aaaaa','aa','aaa']},
-            index: [3,0,5,4,1,2])
-          )
-      end
-
-      it "sorts many vectors" do
-        d = DaruLite::DataFrame.new({a: [1,1,1,222,44,5,5,544], b: [44,44,333,222,111,554,22,3], c: [3,2,5,3,3,1,5,5]})
-
-        expect(d.sort!([:a, :b, :c], ascending: [false, true, false])).to eq(
-          DaruLite::DataFrame.new({a: [544,222,44,5,5,1,1,1], b: [3,222,111,22,554,44,44,333], c: [5,3,3,5,1,3,2,5]},
-            index: [7,3,4,6,5,0,1,2])
-          )
-      end
-
-      it "places nils at the beginning when sorting ascedingly" do
-        d = DaruLite::DataFrame.new({a: [1,1,1,nil,44,5,5,nil], b: [44,44,333,222,111,554,22,3], c: [3,2,5,3,3,1,5,5]})
-
-        expect(d.sort!([:a, :b, :c], ascending: [true, true, false])).to eq(
-          DaruLite::DataFrame.new({a: [nil,nil,1,1,1,5,5,44], b: [3,222,44,44,333,22,554,111], c: [5,3,3,2,5,5,1,3]},
-            index: [7,3,0,1,2,6,5,4])
-          )
-      end
-
-      it "places nils at the beginning when sorting decendingly" do
-        d = DaruLite::DataFrame.new({a: [1,1,1,nil,44,5,5,nil], b: [44,44,333,222,111,554,22,3], c: [3,2,5,3,3,1,5,5]})
-
-        expect(d.sort!([:a, :b, :c], ascending: [false, true, false])).to eq(
-          DaruLite::DataFrame.new({a: [nil,nil,44,5,5,1,1,1], b: [3,222,111,22,554,44,44,333], c: [5,3,3,5,1,3,2,5]},
-            index: [7,3,4,6,5,0,1,2])
-          )
-      end
-
-      it "sorts vectors of non-numeric types with nils in ascending order" do
-        non_numeric = DaruLite::DataFrame.new({a: [5,1,-6,7,5,5], b: [nil,-1,1,nil,-1,1],
-          c: ['aaa','aaa',nil,'baaa','xxx',nil]})
-
-        expect(non_numeric.sort!([:c], ascending: [true])).to eq(
-          DaruLite::DataFrame.new({a: [-6, 5, 5, 1, 7, 5], b: [1, 1, nil, -1, nil, -1],
-            c: [nil, nil, "aaa", "aaa", "baaa", "xxx"]},
-            index: [2, 5, 0, 1, 3, 4])
-          )
-      end
-
-      it "sorts vectors of non-numeric types with nils in descending order" do
-        non_numeric = DaruLite::DataFrame.new({a: [5,1,-6,7,5,5], b: [nil,-1,1,nil,-1,1],
-          c: ['aaa','aaa',nil,'baaa','xxx',nil]})
-
-        expect(non_numeric.sort!([:c], ascending: [false])).to eq(
-          DaruLite::DataFrame.new({a: [-6, 5, 5, 7, 5, 1], b: [1, 1, -1, nil, nil, -1],
-            c: [nil, nil, "xxx", "baaa", "aaa", "aaa"]},
-            index: [2, 5, 4, 3, 0, 1])
-          )
-      end
-
-      it "sorts vectors with block provided and handle nils automatically" do
-        non_numeric = DaruLite::DataFrame.new({a: [5,1,-6,7,5,5], b: [nil,-1,1,nil,-1,1],
-          c: ['aaa','aaa',nil,'baaa','xxx',nil]})
-
-        expect(non_numeric.sort!([:b], by: {b: lambda { |a| a.abs } }, handle_nils: true)).to eq(
-          DaruLite::DataFrame.new({a: [5, 7, 1, -6, 5, 5], b: [nil, nil, -1, 1, -1, 1],
-            c: ["aaa", "baaa", "aaa", nil, "xxx", nil]},
-            index: [0, 3, 1, 2, 4, 5])
-          )
-      end
-
-      it "sorts vectors with block provided and nils handled manually" do
-        non_numeric = DaruLite::DataFrame.new({a: [5,1,-6,7,5,5], b: [nil,-1,1,nil,-1,1],
-          c: ['aaa','aaa',nil,'baaa','xxx',nil]})
-
-      expect(non_numeric.sort!([:b], by: {b: lambda { |a| (a.nil?)?[1]:[0, a.abs]} }, handle_nils: false)).to eq(
-        DaruLite::DataFrame.new({a: [1, -6, 5, 5, 5, 7], b: [-1, 1, -1, 1, nil, nil],
-          c: ["aaa", nil, "xxx", nil, "aaa", "baaa"]},
-          index: [1, 2, 4, 5, 0, 3])
-        )
-      end
-    end
-
-    context DaruLite::MultiIndex do
-      pending
-      it "sorts the DataFrame when specified full tuple" do
-        @df_mi.sort([[:a,:one,:bar]])
-      end
-    end
-  end
-
-  context "#index=" do
-    before :each do
-      @df = DaruLite::DataFrame.new({
-        a: [1,2,3,4,5],
-        b: [11,22,33,44,55],
-        c: %w(a b c d e)
-      })
-    end
-
-    it "simply reassigns the index" do
-      @df.index = DaruLite::Index.new(['4','foo', :bar, 0, 23])
-      expect(@df.row['foo']).to eq(DaruLite::Vector.new([2,22,'b'], index: [:a,:b,:c]))
-    end
-
-    it "raises error for improper length index" do
-      expect {
-        @df.index = DaruLite::Index.new([1,2])
-      }.to raise_error(ArgumentError)
-    end
-
-    it "is able to accept array" do
-      @df.index = (1..5).to_a
-      expect(@df.index).to eq DaruLite::Index.new (1..5).to_a
-    end
-  end
-
-  context '#order=' do
-    let(:df) do
-      DaruLite::DataFrame.new({
-        a: [1, 2, 3],
-        b: [4, 5, 6]
-      }, order: [:a, :b])
-    end
-
-    context 'correct order' do
-      before { df.order = [:b, :a] }
-      subject { df }
-
-      its(:'vectors.to_a') { is_expected.to eq [:b, :a] }
-      its(:'b.to_a') { is_expected.to eq [4, 5, 6] }
-      its(:'a.to_a') { is_expected.to eq [1, 2, 3] }
-    end
-
-    context 'insufficient vectors' do
-      it { expect { df.order = [:a] }.to raise_error }
-    end
-
-    context 'wrong vectors' do
-      it { expect { df.order = [:a, :b, 'b'] }.to raise_error }
-    end
-  end
-
-  context "#vectors=" do
-    before :each do
-      @df = DaruLite::DataFrame.new({
-        a: [1,2,3,4,5],
-        b: [11,22,33,44,55],
-        c: %w(a b c d e)
-      })
-    end
-
-    it "simply reassigns vectors" do
-      @df.vectors = DaruLite::Index.new(['b',0,'m'])
-
-      expect(@df.vectors).to eq(DaruLite::Index.new(['b',0,'m']))
-      expect(@df['b']).to eq(DaruLite::Vector.new([1,2,3,4,5]))
-      expect(@df[0]).to eq(DaruLite::Vector.new([11,22,33,44,55]))
-      expect(@df['m']).to eq(DaruLite::Vector.new(%w(a b c d e)))
-    end
-
-    it "raises error for improper length index" do
-      expect {
-        @df.vectors = DaruLite::Index.new([1,2,'3',4,'5'])
-      }.to raise_error(ArgumentError)
-    end
-
-    it "change name of vectors in @data" do
-      new_index_array = [:k, :l, :m]
-      @df.vectors = DaruLite::Index.new(new_index_array)
-
-      expect(@df.data.map { |vector| vector.name }).to eq(new_index_array)
-    end
-  end
-
-  context "#rename_vectors!" do
-    before do
-      @df = DaruLite::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 = DaruLite::DataFrame.new({
-        a: [1,2,3,4,5],
-        b: [11,22,33,44,55],
-        c: %w(a b c d e)
-      })
-    end
-
-    it "returns DaruLite::Index" do
-      expect(@df.rename_vectors(:a => :alpha)).to be_kind_of(DaruLite::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])
+    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])
     end
 
     it "overwrites vectors if the new name already exists" do
@@ -2832,69 +969,10 @@ describe DaruLite::DataFrame do
     end
   end
 
-  context "#reindex" do
-    it "re indexes and aligns accordingly" do
-      df = DaruLite::DataFrame.new({
-        a: [1,2,3,4,5],
-        b: [11,22,33,44,55],
-        c: %w(a b c d e)
-      })
-
-      ans = df.reindex(DaruLite::Index.new([1,3,0,8,2]))
-      expect(ans).to eq(DaruLite::DataFrame.new({
-        a: [2,4,1,nil,3],
-        b: [22,44,11,nil,33],
-        c: ['b','d','a',nil,'c']
-        }, index: DaruLite::Index.new([1,3,0,8,2])))
-      expect(ans).to_not eq(df)
-    end
-  end
-
-  context "#reindex_vectors" do
-    it "re indexes vectors and aligns accordingly" do
-      df = DaruLite::DataFrame.new({
-        a: [1,2,3,4,5],
-        b: [11,22,33,44,55],
-        c: %w(a b c d e)
-      })
-
-      ans = df.reindex_vectors(DaruLite::Index.new([:b, 'a', :a]))
-      expect(ans).to eq(DaruLite::DataFrame.new({
-        :b  => [11,22,33,44,55],
-        'a' => [nil, nil, nil, nil, nil],
-        :a  => [1,2,3,4,5]
-      }, order: [:b, 'a', :a]))
-    end
-
-    it 'raises ArgumentError if argument was not an index' do
-      df = DaruLite::DataFrame.new([])
-      expect { df.reindex_vectors([]) }.to raise_error(ArgumentError)
-    end
-  end
-
-  context "#to_matrix" do
-    before do
-      @df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
-        c: [11,22,33,44,55], d: [5,4,nil,2,1], e: ['this', 'has', 'string','data','too']},
-        order: [:a, :b, :c,:d,:e],
-        index: [:one, :two, :three, :four, :five])
-    end
-
-    it "concats numeric non-nil vectors to Matrix" do
-      expect(@df.to_matrix).to eq(Matrix[
-        [1,11,11,5],
-        [2,12,22,4],
-        [3,13,33,nil],
-        [4,14,44,2],
-        [5,15,55,1]
-      ])
-    end
-  end
-
   context "#transpose" do
     context DaruLite::Index do
       it "transposes a DataFrame including row and column indexing" do
-        expect(@data_frame.transpose).to eq(DaruLite::DataFrame.new({
+        expect(df.transpose).to eq(DaruLite::DataFrame.new({
           one: [1,11,11],
           two: [2,12,22],
           three: [3,13,33],
@@ -2903,533 +981,37 @@ describe DaruLite::DataFrame do
           }, index: [:a, :b, :c],
           order: [:one, :two, :three, :four, :five])
         )
-      end
-    end
-
-    context DaruLite::MultiIndex do
-      it "transposes a DataFrame including row and column indexing" do
-        expect(@df_mi.transpose).to eq(DaruLite::DataFrame.new([
-          @vector_arry1,
-          @vector_arry2,
-          @vector_arry1,
-          @vector_arry2].transpose, index: @order_mi, order: @multi_index))
-      end
-    end
-  end
-
-  context "#pivot_table" do
-    before do
-      @df = DaruLite::DataFrame.new({
-        a: ['foo'  ,  'foo',  'foo',  'foo',  'foo',  'bar',  'bar',  'bar',  'bar'],
-        b: ['one'  ,  'one',  'one',  'two',  'two',  'one',  'one',  'two',  'two'],
-        c: ['small','large','large','small','small','large','small','large','small'],
-        d: [1,2,2,3,3,4,5,6,7],
-        e: [2,4,4,6,6,8,10,12,14]
-      })
-    end
-
-    it "creates row index as per (single) index argument and default aggregates to mean" do
-      expect(@df.pivot_table(index: [:a])).to eq(DaruLite::DataFrame.new({
-        d: [5.5,2.2],
-        e: [11.0,4.4]
-      }, index: ['bar', 'foo']))
-    end
-
-    it "creates row index as per (double) index argument and default aggregates to mean" do
-      agg_mi = DaruLite::MultiIndex.from_tuples(
-        [
-          ['bar', 'large'],
-          ['bar', 'small'],
-          ['foo', 'large'],
-          ['foo', 'small']
-        ]
-      )
-      expect(@df.pivot_table(index: [:a, :c]).round(2)).to eq(DaruLite::DataFrame.new({
-        d: [5.0 ,  6.0, 2.0, 2.33],
-        e: [10.0, 12.0, 4.0, 4.67]
-      }, index: agg_mi))
-    end
-
-    it "creates row and vector index as per (single) index and (single) vectors args" do
-      agg_vectors = DaruLite::MultiIndex.from_tuples([
-        [:d, 'one'],
-        [:d, 'two'],
-        [:e, 'one'],
-        [:e, 'two']
-      ])
-      agg_index = DaruLite::MultiIndex.from_tuples(
-        [
-          ['bar'],
-          ['foo']
-        ]
-      )
-
-      expect(@df.pivot_table(index: [:a], vectors: [:b]).round(2)).to eq(
-        DaruLite::DataFrame.new(
-          [
-            [4.5, 1.67],
-            [6.5,  3.0],
-            [9.0, 3.33],
-            [13,     6]
-          ], order: agg_vectors, index: agg_index)
-      )
-    end
-
-    it "creates row and vector index as per (single) index and (double) vector args" do
-      agg_vectors = DaruLite::MultiIndex.from_tuples(
-        [
-          [:d, 'one', 'large'],
-          [:d, 'one', 'small'],
-          [:d, 'two', 'large'],
-          [:d, 'two', 'small'],
-          [:e, 'one', 'large'],
-          [:e, 'one', 'small'],
-          [:e, 'two', 'large'],
-          [:e, 'two', 'small']
-        ]
-      )
-
-      agg_index = DaruLite::MultiIndex.from_tuples(
-        [
-          ['bar'],
-          ['foo']
-        ]
-      )
-
-      expect(@df.pivot_table(index: [:a], vectors: [:b, :c])).to eq(DaruLite::DataFrame.new(
-        [
-          [4.0,2.0],
-          [5.0,1.0],
-          [6.0,nil],
-          [7.0,3.0],
-          [8.0,4.0],
-          [10.0,2.0],
-          [12.0,nil],
-          [14.0,6.0]
-        ], order: agg_vectors, index: agg_index
-      ))
-    end
-
-    it "creates row and vector index with (double) index and (double) vector args" do
-      agg_index = DaruLite::MultiIndex.from_tuples([
-        ['bar', 4],
-        ['bar', 5],
-        ['bar', 6],
-        ['bar', 7],
-        ['foo', 1],
-        ['foo', 2],
-        ['foo', 3]
-      ])
-
-      agg_vectors = DaruLite::MultiIndex.from_tuples([
-        [:e, 'one', 'large'],
-        [:e, 'one', 'small'],
-        [:e, 'two', 'large'],
-        [:e, 'two', 'small']
-      ])
-
-      expect(@df.pivot_table(index: [:a, :d], vectors: [:b, :c])).to eq(
-        DaruLite::DataFrame.new(
-          [
-            [8  ,nil,nil,nil,nil,  4,nil],
-            [nil, 10,nil,nil,  2,nil,nil],
-            [nil,nil, 12,nil,nil,nil,nil],
-            [nil,nil,nil, 14,nil,nil,  6],
-          ], index: agg_index, order: agg_vectors)
-      )
-    end
-
-    it "only aggregates over the vector specified in the values argument" do
-      agg_vectors = DaruLite::MultiIndex.from_tuples(
-        [
-          [:e, 'one', 'large'],
-          [:e, 'one', 'small'],
-          [:e, 'two', 'large'],
-          [:e, 'two', 'small']
-        ]
-      )
-      agg_index = DaruLite::MultiIndex.from_tuples(
-        [
-          ['bar'],
-          ['foo']
-        ]
-      )
-      expect(@df.pivot_table(index: [:a], vectors: [:b, :c], values: :e)).to eq(
-        DaruLite::DataFrame.new(
-          [
-            [8,   4],
-            [10,  2],
-            [12,nil],
-            [14,  6]
-          ], order: agg_vectors, index: agg_index
-        )
-      )
-
-      agg_vectors = DaruLite::MultiIndex.from_tuples(
-        [
-          [:d, 'one'],
-          [:d, 'two'],
-          [:e, 'one'],
-          [:e, 'two']
-        ]
-      )
-      expect(@df.pivot_table(index: [:a], vectors: [:b], values: [:d, :e])).to eq(
-        DaruLite::DataFrame.new(
-          [
-            [4.5,  5.0/3],
-            [6.5,    3.0],
-            [9.0, 10.0/3],
-            [13.0,   6.0]
-          ], order: agg_vectors, index: agg_index
-        )
-      )
-    end
-
-    it "overrides default aggregate function to aggregate over sum" do
-      agg_vectors = DaruLite::MultiIndex.from_tuples(
-        [
-          [:e, 'one', 'large'],
-          [:e, 'one', 'small'],
-          [:e, 'two', 'large'],
-          [:e, 'two', 'small']
-        ]
-      )
-      agg_index = DaruLite::MultiIndex.from_tuples(
-        [
-          ['bar'],
-          ['foo']
-        ]
-      )
-      expect(@df.pivot_table(index: [:a], vectors: [:b, :c], values: :e, agg: :sum)).to eq(
-        DaruLite::DataFrame.new(
-          [
-            [8,   8],
-            [10,  2],
-            [12,nil],
-            [14, 12]
-          ], order: agg_vectors, index: agg_index
-        )
-      )
-    end
-
-    it "raises error if no non-numeric vectors are present" do
-      df = DaruLite::DataFrame.new({a: ['a', 'b', 'c'], b: ['b', 'e', 'd']})
-      expect {
-        df.pivot_table(index: [:a])
-      }.to raise_error
-    end
-
-    it "raises error if atleast a row index is not specified" do
-      expect {
-        @df.pivot_table
-      }.to raise_error
-    end
-
-    it "aggregates when nils are present in value vector" do
-      df = DaruLite::DataFrame.new({
-        a: ['foo'  ,  'foo',  'foo',  'foo',  'foo',  'bar',  'bar',  'bar',  'ice'],
-        b: ['one'  ,  'one',  'one',  'two',  'two',  'one',  'one',  'two',  'two'],
-        c: ['small','large','large','small','small','large','small','large','small'],
-        d: [1,2,2,3,3,4,5,6,7],
-        e: [2,nil,4,6,6,8,10,12,nil]
-      })
-
-      expect(df.pivot_table index: [:a]).to eq(
-        DaruLite::DataFrame.new({
-          d:  [5.0, 2.2, 7],
-          e:  [10.0, 4.5, nil]
-        }, index: DaruLite::Index.new(['bar', 'foo', 'ice'])))
-    end
-
-    it "works when nils are present in value vector" do
-      df = DaruLite::DataFrame.new({
-        a: ['foo'  ,  'foo',  'foo',  'foo',  'foo',  'bar',  'bar',  'bar',  'ice'],
-        b: ['one'  ,  'one',  'one',  'two',  'two',  'one',  'one',  'two',  'two'],
-        c: ['small','large','large','small','small','large','small','large','small'],
-        d: [1,2,2,3,3,4,5,6,7],
-        e: [2,nil,4,6,6,8,10,12,nil]
-      })
-
-      agg_vectors = DaruLite::MultiIndex.from_tuples(
-        [
-          [:e, 'one'],
-          [:e, 'two']
-        ]
-      )
-
-      agg_index = DaruLite::MultiIndex.from_tuples(
-        [
-          ['bar'],
-          ['foo'],
-          ['ice']
-        ]
-      )
-
-      expect(df.pivot_table index: [:a], vectors: [:b], values: :e).to eq(
-        DaruLite::DataFrame.new(
-          [
-            [9, 3,  nil],
-            [12, 6, nil]
-          ], order: agg_vectors, index: agg_index
-        )
-      )
-    end
-
-    it 'performs date pivoting' do
-      categories = %i[jan feb mar apr may jun jul aug sep oct nov dec]
-      df = DaruLite::DataFrame.rows([
-        [2014, 2, 1600.0, 20.0],
-        [2014, 3, 1680.0, 21.0],
-        [2016, 2, 1600.0, 20.0],
-        [2016, 4, 1520.0, 19.0],
-      ], order: [:year, :month, :visitors, :days])
-      df[:averages] = df[:visitors] / df[:days]
-      df[:month] = df[:month].map{|i| categories[i - 1]}
-      actual = df.pivot_table(index: :month, vectors: [:year], values: :averages)
-
-      # NB: As you can see, there are some "illogical" parts:
-      #     months are sorted lexicographically, then made into multi-index
-      #     with one-element-per-tuple, then order of columns is dependent
-      #     on which month is lexicographically first (its apr, so, apr-2016
-      #     is first row to gather, so 2016 is first column).
-      #
-      #     All of it is descendance of our group_by implementation (which
-      #     always sorts results & always make array keys). I hope that fixing
-      #     group_by, even to the extend described at https://github.com/v0dro/daru/issues/152,
-      #     will be fix this case also.
-      expected =
-        DaruLite::DataFrame.new(
-          [
-            [80.0, 80.0, nil],
-            [nil, 80.0, 80.0],
-          ], index: DaruLite::MultiIndex.from_tuples([[:apr], [:feb], [:mar]]),
-          order: DaruLite::MultiIndex.from_tuples([[:averages, 2016], [:averages, 2014]])
-        )
-      # Comparing their parts previous to full comparison allows to
-      # find complicated differences.
-      expect(actual.vectors).to eq expected.vectors
-      expect(actual.index).to eq expected.index
-      expect(actual).to eq expected
-    end
-  end
-
-  context "#shape" do
-    it "returns an array containing number of rows and columns" do
-      expect(@data_frame.shape).to eq([5,3])
-    end
-  end
-
-  context "#nest" do
-    it "nests in a hash" do
-      df = DaruLite::DataFrame.new({
-        :a => DaruLite::Vector.new(%w(a a a b b b)),
-        :b => DaruLite::Vector.new(%w(c c d d e e)),
-        :c => DaruLite::Vector.new(%w(f g h i j k))
-      })
-      nest = df.nest :a, :b
-      expect(nest['a']['c']).to eq([{ :c => 'f' }, { :c => 'g' }])
-      expect(nest['a']['d']).to eq([{ :c => 'h' }])
-      expect(nest['b']['e']).to eq([{ :c => 'j' }, { :c => 'k' }])
-    end
-  end
-
-  context "#summary" do
-    subject { df.summary }
-
-    context "DataFrame" do
-      let(:df) { DaruLite::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
-
-  context '#to_df' do
-    it 'returns the dataframe' do
-      @data_frame.to_df == @data_frame
-    end
-  end
-
-  context "#merge" do
-    it "merges one dataframe with another" do
-      a = DaruLite::Vector.new [1, 2, 3]
-      b = DaruLite::Vector.new [3, 4, 5]
-      c = DaruLite::Vector.new [4, 5, 6]
-      d = DaruLite::Vector.new [7, 8, 9]
-      e = DaruLite::Vector.new [10, 20, 30]
-      ds1 = DaruLite::DataFrame.new({ :a => a, :b => b })
-      ds2 = DaruLite::DataFrame.new({ :c => c, :d => d })
-      exp = DaruLite::DataFrame.new({ :a => a, :b => b, :c => c, :d => d })
-
-      expect(ds1.merge(ds2)).to eq(exp)
-      expect(ds2.merge(ds1)).to eq(
-        DaruLite::DataFrame.new({c: c, d: d, a: a, b: b}, order: [:c, :d, :a, :b]))
-
-      ds3 = DaruLite::DataFrame.new({ :a => e })
-      exp = DaruLite::DataFrame.new({ :a_1 => a, :a_2 => e, :b => b },
-        order: [:a_1, :b, :a_2])
-
-      expect(ds1.merge(ds3)).to eq(exp)
-    end
-
-    context "preserves type of vector names" do
-      let(:df1) { DaruLite::DataFrame.new({'a'=> [1, 2, 3]}) }
-      let(:df2) { DaruLite::DataFrame.new({:b=> [4, 5, 6]}) }
-      subject { df1.merge df2 }
-
-      it { is_expected.to be_a DaruLite::DataFrame }
-      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) { DaruLite::DataFrame.new({ 'a' => [1, 2, 3], 'b' => [3, 4, 5] }, index: index) }
-      let(:df2) { DaruLite::DataFrame.new({ 'c' => [4, 5, 6], 'd' => [7, 8, 9] }, index: index) }
-      subject { df1.merge df2 }
-
-      its(:index) { is_expected.to eq DaruLite::Index.new(index) }
-    end
-  end
-
-  context "#vector_by_calculation" do
-    it "DSL for returning vector of each calculation" do
-      a1 = DaruLite::Vector.new([1, 2, 3, 4, 5, 6, 7])
-      a2 = DaruLite::Vector.new([10, 20, 30, 40, 50, 60, 70])
-      a3 = DaruLite::Vector.new([100, 200, 300, 400, 500, 600, 700])
-      ds = DaruLite::DataFrame.new({ :a => a1, :b => a2, :c => a3 })
-      total = ds.vector_by_calculation { a + b + c }
-      expected = DaruLite::Vector.new([111, 222, 333, 444, 555, 666, 777])
-      expect(total).to eq(expected)
-    end
-  end
-
-  context "group_by" do
-    context "on a single row DataFrame" do
-      let(:df){ DaruLite::DataFrame.new(city: %w[Kyiv], year: [2015], value: [1]) }
-      it "returns a groupby object" do
-        expect(df.group_by([:city])).to be_a(DaruLite::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 = DaruLite::Vector.new [1, 2, 3, 4, 5, nil, nil]
-      a2 = DaruLite::Vector.new [10, 10, 20, 20, 20, 30, nil]
-      b1 = DaruLite::Vector.new [nil, 1, 1, 1, 1, 2, nil]
-      b2 = DaruLite::Vector.new [2, 2, 2, nil, 2, 3, nil]
-      @df = DaruLite::DataFrame.new({ :a1 => a1, :a2 => a2, :b1 => b1, :b2 => b2 })
-    end
-
-    it "calculates complete vector sum" do
-      expect(@df.vector_sum).to eq(DaruLite::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(DaruLite::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(DaruLite::Vector.new [11, 12, 23, 24, 25, nil, nil])
-      expect(b).to eq(DaruLite::Vector.new [nil, 3, 3, nil, 3, 5, nil])
-    end
-  end
-
-  context "#missing_values_rows" do
-    it "returns number of missing values in each row" do
-      a1 = DaruLite::Vector.new [1, nil, 3, 4, 5, nil]
-      a2 = DaruLite::Vector.new [10, nil, 20, 20, 20, 30]
-      b1 = DaruLite::Vector.new [nil, nil, 1, 1, 1, 2]
-      b2 = DaruLite::Vector.new [2, 2, 2, nil, 2, 3]
-      c  = DaruLite::Vector.new [nil, 2, 4, 2, 2, 2]
-      df = DaruLite::DataFrame.new({
-        :a1 => a1, :a2 => a2, :b1 => b1, :b2 => b2, :c => c })
-
-      expect(df.missing_values_rows).to eq(DaruLite::Vector.new [2, 3, 0, 1, 0, 1])
+      end
     end
-  end
 
-  context "#vector_count_characters" do
-    it "" do
-      a1  = DaruLite::Vector.new( [1, 'abcde', 3, 4, 5, nil])
-      a2  = DaruLite::Vector.new( [10, 20.3, 20, 20, 20, 30])
-      b1  = DaruLite::Vector.new( [nil, '343434', 1, 1, 1, 2])
-      b2  = DaruLite::Vector.new( [2, 2, 2, nil, 2, 3])
-      c   = DaruLite::Vector.new([nil, 2, 'This is a nice example', 2, 2, 2])
-      ds  = DaruLite::DataFrame.new({ :a1 => a1, :a2 => a2, :b1 => b1, :b2 => b2, :c => c })
-
-      expect(ds.vector_count_characters).to eq(DaruLite::Vector.new([4, 17, 27, 5, 6, 5]))
+    context DaruLite::MultiIndex do
+      it "transposes a DataFrame including row and column indexing" do
+        expect(df_mi.transpose).to eq(DaruLite::DataFrame.new([
+          vector_arry1,
+          vector_arry2,
+          vector_arry1,
+          vector_arry2].transpose, index: order_mi, order: multi_index))
+      end
     end
   end
 
-  context '#include_values?' do
-    let(:df) do
-      DaruLite::DataFrame.new({
-        a: [1,   2,  3,   4,          Float::NAN, 6, 1],
-        b: [:a,  :b, nil, Float::NAN, nil,        3, 5],
-        c: ['a', 6,  3,   4,          3,          5, 3],
-        d: [1,   2,  3,   5,          1,          2, 5]
-      })
-    end
-    before { df.to_category :b }
-
-    context 'true' do
-      it { expect(df.include_values? nil).to eq true }
-      it { expect(df.include_values? Float::NAN).to eq true }
-      it { expect(df.include_values? nil, Float::NAN).to eq true }
-      it { expect(df.include_values? 1, 30).to eq true }
-    end
-
-    context 'false' do
-      it { expect(df[:a, :c].include_values? nil).to eq false }
-      it { expect(df[:c, :d].include_values? Float::NAN).to eq false }
-      it { expect(df[:c, :d].include_values? nil, Float::NAN).to eq false }
-      it { expect(df.include_values? 10, 20).to eq false }
+  context "#shape" do
+    it "returns an array containing number of rows and columns" do
+      expect(df.shape).to eq([5,3])
     end
   end
 
-  context "#vector_mean" do
-    before do
-      a1 = DaruLite::Vector.new [1, 2, 3, 4, 5, nil]
-      a2 = DaruLite::Vector.new [10, 10, 20, 20, 20, 30]
-      b1 = DaruLite::Vector.new [nil, 1, 1, 1, 1, 2]
-      b2 = DaruLite::Vector.new [2, 2, 2, nil, 2, 3]
-      c  = DaruLite::Vector.new [nil, 2, 4, 2, 2, 2]
-      @df = DaruLite::DataFrame.new({
-        :a1 => a1, :a2 => a2, :b1 => b1, :b2 => b2, :c => c })
-    end
-
-    it "calculates complete vector mean" do
-      expect(@df.vector_mean).to eq(
-        DaruLite::Vector.new [nil, 3.4, 6, nil, 6.0, nil])
+  context "#nest" do
+    it "nests in a hash" do
+      df = DaruLite::DataFrame.new({
+        :a => DaruLite::Vector.new(%w(a a a b b b)),
+        :b => DaruLite::Vector.new(%w(c c d d e e)),
+        :c => DaruLite::Vector.new(%w(f g h i j k))
+      })
+      nest = df.nest :a, :b
+      expect(nest['a']['c']).to eq([{ :c => 'f' }, { :c => 'g' }])
+      expect(nest['a']['d']).to eq([{ :c => 'h' }])
+      expect(nest['b']['e']).to eq([{ :c => 'j' }, { :c => 'k' }])
     end
   end
 
@@ -3473,64 +1055,6 @@ describe DaruLite::DataFrame do
     end
   end
 
-  context "#verify" do
-    def create_test(*args, &proc)
-      description = args.shift
-      fields = args
-      [description, fields, proc]
-    end
-
-    before do
-      name = DaruLite::Vector.new %w(r1 r2 r3 r4)
-      v1   = DaruLite::Vector.new [1, 2, 3, 4]
-      v2   = DaruLite::Vector.new [4, 3, 2, 1]
-      v3   = DaruLite::Vector.new [10, 20, 30, 40]
-      v4   = DaruLite::Vector.new %w(a b a b)
-      @df = DaruLite::DataFrame.new({
-        :v1 => v1, :v2 => v2, :v3 => v3, :v4 => v4, :id => name
-        }, order: [:v1, :v2, :v3, :v4, :id])
-    end
-
-    it "correctly verifies data as per the block" do
-      # Correct
-      t1 = create_test('If v4=a, v1 odd') do |r|
-        r[:v4] == 'b' or (r[:v4] == 'a' and r[:v1].odd?)
-      end
-      t2 = create_test('v3=v1*10')  { |r| r[:v3] == r[:v1] * 10 }
-      # Fail!
-      t3 = create_test("v4='b'") { |r| r[:v4] == 'b' }
-      exp1 = ["1 [1]: v4='b'", "3 [3]: v4='b'"]
-      exp2 = ["1 [r1]: v4='b'", "3 [r3]: v4='b'"]
-
-      dataf = @df.verify(t3, t1, t2)
-      expect(dataf).to eq(exp1)
-    end
-
-    it "uses additional fields to extend error messages" do
-      t = create_test("v4='b'", :v2, :v3) { |r| r[:v4] == 'b' }
-
-      dataf = @df.verify(:id, t)
-      expect(dataf).to eq(["1 [r1]: v4='b' (v2=4, v3=10)", "3 [r3]: v4='b' (v2=2, v3=30)"])
-    end
-  end
-
-  context "#compute" do
-    it "performs a computation when supplied in a string" do
-      v1       = DaruLite::Vector.new [1, 2, 3, 4]
-      v2       = DaruLite::Vector.new [4, 3, 2, 1]
-      v3       = DaruLite::Vector.new [10, 20, 30, 40]
-      vnumeric = DaruLite::Vector.new [0, 0, 1, 4]
-      vsum     = DaruLite::Vector.new [1 + 4 + 10.0, 2 + 3 + 20.0, 3 + 2 + 30.0, 4 + 1 + 40.0]
-      vmult    = DaruLite::Vector.new [1 * 4, 2 * 3, 3 * 2, 4 * 1]
-
-      df = DaruLite::DataFrame.new({:v1 => v1, :v2 => v2, :v3 => v3})
-
-      expect(df.compute("v1/v2")).to eq(vnumeric)
-      expect(df.compute("v1+v2+v3")).to eq(vsum)
-      expect(df.compute("v1*v2")).to eq(vmult)
-    end
-  end
-
   context ".crosstab_by_assignation" do
     it "" do
       v1 = DaruLite::Vector.new %w(a a a b b b c c c)
@@ -3554,394 +1078,6 @@ describe DaruLite::DataFrame do
     end
   end
 
-  context "#one_to_many" do
-    it "" do
-      rows = [
-        ['1', 'george', 'red', 10, 'blue', 20, nil, nil],
-        ['2', 'fred', 'green', 15, 'orange', 30, 'white', 20],
-        ['3', 'alfred', nil, nil, nil, nil, nil, nil]
-      ]
-
-      df = DaruLite::DataFrame.rows(rows,
-        order: ['id', 'name', 'car_color1', 'car_value1', 'car_color2',
-          'car_value2', 'car_color3', 'car_value3'])
-
-      ids     = DaruLite::Vector.new %w(1 1 2 2 2)
-      colors  = DaruLite::Vector.new %w(red blue green orange white)
-      values  = DaruLite::Vector.new [10, 20, 15, 30, 20]
-      col_ids = DaruLite::Vector.new [1, 2, 1, 2, 3]
-
-      df_expected = DaruLite::DataFrame.new({
-        'id' => ids, '_col_id' => col_ids, 'color' => colors, 'value' => values
-        }, order: ['id', '_col_id', 'color', 'value'])
-
-      expect(df.one_to_many(['id'], 'car_%v%n')).to eq(df_expected)
-    end
-  end
-
-  context "#any?" do
-    before do
-      @df = DaruLite::DataFrame.new({
-        a: [1,2,3,4,5],
-        b: [10,20,30,40,50],
-        c: [11,22,33,44,55]})
-    end
-
-    it "returns true if any one of the vectors satisfy condition" do
-      expect(@df.any? { |v| v[0] == 1 }).to eq(true)
-    end
-
-    it "returns false if none of the vectors satisfy the condition" do
-      expect(@df.any? { |v| v.mean > 100 }).to eq(false)
-    end
-
-    it "returns true if any one of the rows satisfy condition" do
-      expect(@df.any?(:row) { |r| r[:a] == 1 and r[:c] == 11 }).to eq(true)
-    end
-
-    it "returns false if none of the rows satisfy the condition" do
-      expect(@df.any?(:row) { |r| r.mean > 100 }).to eq(false)
-    end
-
-    it 'fails on unknown axis' do
-      expect { @df.any?(:kitten) { |r| r.mean > 100 } }.to raise_error ArgumentError, /axis/
-    end
-  end
-
-  context "#all?" do
-    before do
-      @df = DaruLite::DataFrame.new({
-        a: [1,2,3,4,5],
-        b: [10,20,30,40,50],
-        c: [11,22,33,44,55]})
-    end
-
-    it "returns true if all of the vectors satisfy condition" do
-      expect(@df.all? { |v| v.mean < 40 }).to eq(true)
-    end
-
-    it "returns false if any one of the vectors does not satisfy condition" do
-      expect(@df.all? { |v| v.mean == 30 }).to eq(false)
-    end
-
-    it "returns true if all of the rows satisfy condition" do
-      expect(@df.all?(:row) { |r| r.mean < 70 }).to eq(true)
-    end
-
-    it "returns false if any one of the rows does not satisfy condition" do
-      expect(@df.all?(:row) { |r| r.mean == 30 }).to eq(false)
-    end
-
-    it 'fails on unknown axis' do
-      expect { @df.all?(:kitten) { |r| r.mean > 100 } }.to raise_error ArgumentError, /axis/
-    end
-  end
-
-  context "#only_numerics" do
-    before do
-      @v1 = DaruLite::Vector.new([1,2,3,4,5])
-      @v2 = DaruLite::Vector.new(%w(one two three four five))
-      @v3 = DaruLite::Vector.new([11,22,33,44,55])
-      @df = DaruLite::DataFrame.new({
-        a: @v1, b: @v2, c: @v3 }, clone: false)
-    end
-
-    it "returns a view of only the numeric vectors" do
-      dfon = @df.only_numerics(clone: false)
-
-      expect(dfon).to eq(
-        DaruLite::DataFrame.new({ a: @v1, c: @v3 }, clone: false))
-      expect(dfon[:a].object_id).to eq(@v1.object_id)
-    end
-
-    it "returns a clone of numeric vectors" do
-      dfon = @df.only_numerics
-
-      expect(dfon).to eq(
-        DaruLite::DataFrame.new({ a: @v1, c: @v3}, clone: false)
-      )
-      expect(dfon[:a].object_id).to_not eq(@v1.object_id)
-    end
-
-    context DaruLite::MultiIndex do
-      before do
-        agg_vectors = DaruLite::MultiIndex.from_tuples(
-          [
-            [:d, :one, :large],
-            [:d, :one, :small],
-            [:d, :two, :large],
-            [:d, :two, :small],
-            [:e, :one, :large],
-            [:e, :one, :small],
-            [:e, :two, :large],
-            [:e, :two, :small]
-          ]
-        )
-
-        agg_index = DaruLite::MultiIndex.from_tuples(
-          [
-            [:bar],
-            [:foo]
-          ]
-        )
-        @df = DaruLite::DataFrame.new(
-          [
-            [4.112,2.234],
-            %w(a b),
-            [6.342,nil],
-            [7.2344,3.23214],
-            [8.234,4.533],
-            [10.342,2.3432],
-            [12.0,nil],
-            %w(a b)
-          ], order: agg_vectors, index: agg_index
-        )
-      end
-
-      it "returns numeric vectors" do
-        vectors = DaruLite::MultiIndex.from_tuples(
-          [
-            [:d, :one, :large],
-            [:d, :two, :large],
-            [:d, :two, :small],
-            [:e, :one, :large],
-            [:e, :one, :small],
-            [:e, :two, :large]
-          ]
-        )
-
-        index = DaruLite::MultiIndex.from_tuples(
-          [
-            [:bar],
-            [:foo]
-          ]
-        )
-        answer = DaruLite::DataFrame.new(
-          [
-            [4.112,2.234],
-            [6.342,nil],
-            [7.2344,3.23214],
-            [8.234,4.533],
-            [10.342,2.3432],
-            [12.0,nil],
-          ], order: vectors, index: index
-        )
-
-        expect(@df.only_numerics).to eq(answer)
-      end
-    end
-  end
-
-  context '#reset_index' do
-    context 'when Index' do
-      subject do
-        DaruLite::DataFrame.new(
-          {'vals' => [1,2,3,4,5]},
-          index: DaruLite::Index.new(%w[a b c d e], name: 'indices')
-        ).reset_index
-      end
-
-      it { is_expected.to eq DaruLite::DataFrame.new(
-        'indices' => %w[a b c d e],
-        'vals' => [1,2,3,4,5]
-      )}
-    end
-
-    context 'when MultiIndex' do
-      subject do
-        mi = DaruLite::MultiIndex.from_tuples([
-          [0, 'a'], [0, 'b'], [1, 'a'], [1, 'b']
-        ])
-        mi.name = %w[nums alphas]
-        DaruLite::DataFrame.new(
-          {'vals' => [1,2,3,4]},
-          index: mi
-        ).reset_index
-      end
-
-      it { is_expected.to eq DaruLite::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 = DaruLite::DataFrame.new({
-        a: [1,2,3,4,5],
-        b: ['a','b','c','d','e'],
-        c: [11,22,33,44,55]
-        })
-    end
-
-    it "sets a particular column as the index and deletes that column" do
-      @df.set_index(:b)
-      expect(@df).to eq(
-        DaruLite::DataFrame.new({
-          a: [1,2,3,4,5],
-          c: [11,22,33,44,55]
-          }, index: ['a','b','c','d','e'])
-        )
-    end
-
-    it "sets a particular column as index but keeps that column" do
-      expect(@df.set_index(:c, keep: true)).to eq(
-        DaruLite::DataFrame.new({
-          a: [1,2,3,4,5],
-          b: ['a','b','c','d','e'],
-          c: [11,22,33,44,55]
-          }, index: [11,22,33,44,55]))
-      expect(@df[:c]).to eq(@df[:c])
-    end
-
-    it "sets categorical index if categorical is true" do
-      data = {
-        a: [1, 2, 3, 4, 5],
-        b: [:a, 1, :a, 1, 'c'],
-        c: %w[a b c d e]
-      }
-      df = DaruLite::DataFrame.new(data)
-      df.set_index(:b, categorical: true)
-      expected = DaruLite::DataFrame.new(
-        data.slice(:a, :c),
-        index: DaruLite::CategoricalIndex.new(data[:b])
-      )
-      expect(df).to eq(expected)
-    end
-
-    it "raises error if all elements in the column aren't unique" do
-      jholu = DaruLite::DataFrame.new({
-        a: ['a','b','a'],
-        b: [1,2,4]
-        })
-
-      expect {
-        jholu.set_index(:a)
-      }.to raise_error(ArgumentError)
-    end
-
-    it "sets multiindex if array is given" do
-      df = DaruLite::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 =
-        DaruLite::DataFrame.new(
-          { c: %w[a b c d] },
-          index: DaruLite::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
-    before do
-      @df1 = DaruLite::DataFrame.new({
-        a: [1, 2, 3],
-        b: [1, 2, 3]
-      })
-
-      @df2 = DaruLite::DataFrame.new({
-        a: [4, 5, 6],
-        c: [4, 5, 6]
-      })
-    end
-
-    it 'does not modify the original dataframes' do
-      df1_a = @df1[:a].to_a.dup
-      df2_a = @df2[:a].to_a.dup
-
-      df_concat = @df1.concat @df2
-      expect(@df1[:a].to_a).to eq df1_a
-      expect(@df2[:a].to_a).to eq df2_a
-    end
-
-    it 'creates a new dataframe that is a concatenation of the two dataframe arguments' do
-      df1_a = @df1[:a].to_a.dup
-      df2_a = @df2[:a].to_a.dup
-
-      df_concat = @df1.concat @df2
-      expect(df_concat[:a].to_a).to eq df1_a + df2_a
-    end
-
-    it 'fills in missing vectors with nils' do
-      df1_b = @df1[:b].to_a.dup
-      df2_c = @df2[:c].to_a.dup
-
-      df_concat = @df1.concat @df2
-      expect(df_concat[:b].to_a).to eq df1_b + [nil] * @df2.size
-      expect(df_concat[:c].to_a).to eq [nil] * @df1.size + df2_c
-    end
-
-  end
-
-  context "#union" do
-    before do
-      @df1 = DaruLite::DataFrame.new({
-        a: [1, 2, 3],
-        b: [1, 2, 3]},
-        index: [1,3,5] )
-
-      @df2 = DaruLite::DataFrame.new({
-        a: [4, 5, 6],
-        c: [4, 5, 6]},
-        index: [7,9,11])
-
-      @df3 = DaruLite::DataFrame.new({
-        a: [4, 5, 6],
-        c: [4, 5, 6]},
-        index: [5,7,9])
-    end
-
-    it 'does not modify the original dataframes' do
-      df1_a = @df1[:a].to_a.dup
-      df2_a = @df2[:a].to_a.dup
-
-      _ = @df1.union @df2
-      expect(@df1[:a].to_a).to eq df1_a
-      expect(@df2[:a].to_a).to eq df2_a
-    end
-
-    it 'creates a new dataframe that is a concatenation of the two dataframe arguments' do
-      df1_a = @df1[:a].to_a.dup
-      df2_a = @df2[:a].to_a.dup
-
-      df_union = @df1.union @df2
-      expect(df_union[:a].to_a).to eq df1_a + df2_a
-    end
-
-    it 'fills in missing vectors with nils' do
-      df1_b = @df1[:b].to_a.dup
-      df2_c = @df2[:c].to_a.dup
-
-      df_union = @df1.union @df2
-      expect(df_union[:b].to_a).to eq df1_b + [nil] * @df2.size
-      expect(df_union[:c].to_a).to eq [nil] * @df1.size + df2_c
-    end
-
-    it 'overwrites part of the first dataframe if there are double indices' do
-      vec = DaruLite::Vector.new({a: 4, b: nil, c: 4})
-      expect(@df1.union(@df3).row[5]).to eq vec
-    end
-
-    it 'concats the indices' do
-      v1 = @df1.index.to_a
-      v2 = @df2.index.to_a
-
-      df_union = @df1.union @df2
-      expect(df_union.index.to_a).to eq v1 + v2
-    end
-  end
-
   context '#inspect' do
     subject { df.inspect }
 
@@ -4021,6 +1157,18 @@ describe DaruLite::DataFrame do
        }.unindent}
     end
 
+    context 'with integers as vectors names' do
+      let(:df) { DaruLite::DataFrame.new({ 1 => [1,2,3], b: [3,4,5], c: [6,7,8] }, name: 'test')}
+
+      it { is_expected.to eq %Q{
+        |#<DaruLite::DataFrame: test (3x3)>
+        |       1   b   c
+        |   0   1   3   6
+        |   1   2   4   7
+        |   2   3   5   8
+       }.unindent}
+    end
+
     context 'very long' do
       let(:df) { DaruLite::DataFrame.new({a: [1,1,1]*20, b: [1,1,1]*20, c: [1,1,1]*20}, name: 'test')}
       it { is_expected.to eq %Q{
@@ -4110,189 +1258,6 @@ describe DaruLite::DataFrame do
     end
   end
 
-  context '#to_s' do
-    it 'produces a class, size description' do
-      expect(@data_frame.to_s).to eq "#<DaruLite::DataFrame(5x3)>"
-    end
-
-    it 'produces a class, name, size description' do
-      @data_frame.name = "Test"
-      expect(@data_frame.to_s).to eq "#<DaruLite::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 "#<DaruLite::DataFrame: Test(5x3)>"
-    end
-  end
-
-  context '#to_json' do
-    let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]}, index: [:one, :two, :three], name: 'test')}
-    subject { JSON.parse(json) }
-
-    context 'with index' do
-      let(:json) { df.to_json(false) }
-      # FIXME: is it most reasonable we can do?.. -- zverok
-      # For me, more resonable thing would be something like
-      #
-      # [
-      #   {"index" => "one"  , "a"=>1, "b"=>3, "c"=>6},
-      #   {"index" => "two"  , "a"=>2, "b"=>4, "c"=>7},
-      #   {"index" => "three", "a"=>3, "b"=>5, "c"=>8}
-      # ]
-      #
-      # Or maybe
-      #
-      # [
-      #   ["one"  , {"a"=>1, "b"=>3, "c"=>6}],
-      #   ["two"  , {"a"=>2, "b"=>4, "c"=>7}],
-      #   ["three", {"a"=>3, "b"=>5, "c"=>8}]
-      # ]
-      #
-      # Or even
-      #
-      # {
-      #   "one"   => {"a"=>1, "b"=>3, "c"=>6},
-      #   "two"   => {"a"=>2, "b"=>4, "c"=>7},
-      #   "three" => {"a"=>3, "b"=>5, "c"=>8}
-      # }
-      #
-      it { is_expected.to eq(
-        [
-          [
-            {"a"=>1, "b"=>3, "c"=>6},
-            {"a"=>2, "b"=>4, "c"=>7},
-            {"a"=>3, "b"=>5, "c"=>8}
-          ],
-          ["one", "two", "three"]
-        ]
-      )}
-    end
-
-    context 'without index' do
-      let(:json) { df.to_json(true) }
-      it { is_expected.to eq(
-        [
-          {"a"=>1, "b"=>3, "c"=>6},
-          {"a"=>2, "b"=>4, "c"=>7},
-          {"a"=>3, "b"=>5, "c"=>8}
-        ]
-      )}
-    end
-  end
-
-  context '#access_row_tuples_by_indexs' do
-    let(:df) {
-      DaruLite::DataFrame.new({col: [:a, :b, :c, :d, :e], num: [52,12,07,17,01]}) }
-    let(:df_idx) {
-      DaruLite::DataFrame.new({a: [52, 12, 07], b: [1, 2, 3]}, index: [:one, :two, :three])
-    }
-    let (:mi_idx) do
-      DaruLite::MultiIndex.from_tuples [
-        [:a,:one,:bar],
-        [:a,:one,:baz],
-        [:b,:two,:bar],
-        [:a,:two,:baz],
-      ]
-    end
-    let (:df_mi) do
-      DaruLite::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) { DaruLite::CategoricalIndex.new [:a, :b, :a, :a, :c] }
-    let(:df) { DaruLite::DataFrame.new(num: [52,12,07,17,01], cat_index: cat_idx) }
-    let(:df_cat_idx) {
-      DaruLite::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(
-          DaruLite::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(
-          DaruLite::DataFrame.new({num: [76, 12, 1]}, index: [:a, :b, :c])
-        )
-    end
-  end
-
-  context '#group_by_and_aggregate' do
-    let(:spending_df) {
-      DaruLite::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) { DaruLite::DataFrame.new({
-        a: [1,2,3],
-        b: ['test', 'me', 'please'],
-        c: ['2015-06-01', '2015-06-02', '2015-06-03']
-      },
-      name: 'test'
-    )}
-    subject { df.create_sql('foo') }
-    it { is_expected.to eq %Q{
-      |CREATE TABLE foo (a INTEGER,
-      | b VARCHAR (255),
-      | c DATE) CHARACTER SET=UTF8;
-    }.unindent}
-  end
-
   context "#by_single_key" do
     let(:df) { DaruLite::DataFrame.new(a: [1, 2, 3], b: [4, 5, 6] ) }
 
@@ -4300,31 +1265,4 @@ describe DaruLite::DataFrame do
       expect { df[:c] }.to raise_error(IndexError, /Specified vector c does not exist/)
     end
   end
-
-  context "#rotate_vectors" do
-    subject { df.rotate_vectors(-1) }
-
-    context "several vectors in the dataframe" do
-      let(:df) do
-        DaruLite::DataFrame.new({
-          a: [1,2,3],
-          b: [4,5,6],
-          total: [5,7,9]
-        })
-      end
-      let(:new_order) { [:total, :a, :b] }
-
-      it "return the dataframe with the position of the last vector change to first" do
-        expect(subject.vectors.to_a).to eq(new_order)
-      end
-    end
-
-    context "only one vector in the dataframe" do
-      let(:df) { DaruLite::DataFrame.new({ a: [1,2,3] }) }
-
-      it "return the dataframe without any change" do
-        expect(subject).to eq(df)
-      end
-    end
-  end
 end if mri?