daru_lite 0.1

data/spec/dataframe_spec.rb

@@ -0,0 +1,4330 @@
+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]},
+      order: [:a, :b, :c],
+      index: [:one, :two, :three, :four, :five])
+    tuples = [
+      [:a,:one,:bar],
+      [:a,:one,:baz],
+      [:a,:two,:bar],
+      [:a,:two,:baz],
+      [:b,:one,:bar],
+      [:b,:two,:bar],
+      [:b,:two,:baz],
+      [:b,:one,:foo],
+      [:c,:one,:bar],
+      [:c,:one,:baz],
+      [: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)
+  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]
+      ]
+    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
+
+  context "#initialize" do
+
+    it "initializes an empty DataFrame with no arguments" do
+      df = DaruLite::DataFrame.new
+      expect(df.nrows).to eq(0)
+      expect(df.ncols).to eq(0)
+    end
+
+    context DaruLite::Index do
+      it "initializes an empty DataFrame with empty source arg" do
+        df = DaruLite::DataFrame.new({}, order: [:a, :b])
+
+        expect(df.vectors).to eq(DaruLite::Index.new [:a, :b])
+        expect(df.a.class).to eq(DaruLite::Vector)
+        expect(df.a)      .to eq([].dv(:a))
+      end
+
+      it "initializes from a Hash" do
+        df = 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.index)  .to eq(DaruLite::Index.new [:one, :two, :three, :four, :five])
+        expect(df.vectors).to eq(DaruLite::Index.new [:a, :b])
+        expect(df.a.class).to eq(DaruLite::Vector)
+        expect(df.a)      .to eq([1,2,3,4,5].dv(:a, df.index))
+      end
+
+      it "initializes from a Hash and preserves default order" do
+        df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]},
+          index: [:one, :two, :three, :four, :five])
+
+        expect(df.vectors).to eq(DaruLite::Index.new [:b, :a])
+      end
+
+      it "initializes from a Hash of Vectors" do
+        va = DaruLite::Vector.new([1,2,3,4,5], index: [:one, :two, :three, :four, :five])
+        vb = DaruLite::Vector.new([11,12,13,14,15], index: [:one, :two, :three, :four, :five])
+
+        df = DaruLite::DataFrame.new({ b: vb, a: va }, order: [:a, :b], index: [:one, :two, :three, :four, :five])
+
+        expect(df.index)  .to eq(DaruLite::Index.new [:one, :two, :three, :four, :five])
+        expect(df.vectors).to eq(DaruLite::Index.new [:a, :b])
+        expect(df.a.class).to eq(DaruLite::Vector)
+        expect(df.a)      .to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
+      end
+
+      it "initializes from an Array of Hashes" do
+        df = DaruLite::DataFrame.new([{a: 1, b: 11}, {a: false, b: 12}, {a: 3, b: 13},
+          {a: 4, b: 14}, {a: 5, b: 15}], order: [:b, :a],
+          index: [:one, :two, :three, :four, :five])
+
+        expect(df.index)  .to eq(DaruLite::Index.new [:one, :two, :three, :four, :five])
+        expect(df.vectors).to eq(DaruLite::Index.new [:b, :a])
+        expect(df.a.class).to eq(DaruLite::Vector)
+        expect(df.a)      .to eq([1,false,3,4,5].dv(:a,[:one, :two, :three, :four, :five]))
+      end
+
+      it "initializes from Array of Arrays" do
+        df = DaruLite::DataFrame.new([[1]*5, [2]*5, [3]*5], order: [:b, :a, :c])
+
+        expect(df.index)  .to eq(DaruLite::Index.new(5))
+        expect(df.vectors).to eq(DaruLite::Index.new([:b, :a, :c]))
+        expect(df.a)      .to eq(DaruLite::Vector.new([2]*5))
+      end
+
+      it "initializes from Array of Vectors" do
+        df = DaruLite::DataFrame.new([DaruLite::Vector.new([1]*5), DaruLite::Vector.new([2]*5),
+         DaruLite::Vector.new([3]*5)], order: [:b, :a, :c])
+
+        expect(df.index)  .to eq(DaruLite::Index.new(5))
+        expect(df.vectors).to eq(DaruLite::Index.new([:b, :a, :c]))
+        expect(df.a)      .to eq(DaruLite::Vector.new([2]*5))
+      end
+
+      it "accepts Index objects for row/col" do
+        rows = DaruLite::Index.new [:one, :two, :three, :four, :five]
+        cols = DaruLite::Index.new [:a, :b]
+
+        df  = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, order: cols,
+          index: rows)
+
+        expect(df.a)      .to eq(DaruLite::Vector.new([1,2,3,4,5], order: [:a], index: rows))
+        expect(df.b)      .to eq(DaruLite::Vector.new([11,12,13,14,15], name: :b, index: rows))
+        expect(df.index)  .to eq(DaruLite::Index.new [:one, :two, :three, :four, :five])
+        expect(df.vectors).to eq(DaruLite::Index.new [:a, :b])
+      end
+
+      it "initializes without specifying row/col index" do
+        df = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]})
+
+        expect(df.index)  .to eq(DaruLite::Index.new [0,1,2,3,4])
+        expect(df.vectors).to eq(DaruLite::Index.new [:b, :a])
+      end
+
+      it "aligns indexes properly" do
+        df = DaruLite::DataFrame.new({
+            b: [11,12,13,14,15].dv(:b, [:two, :one, :four, :five, :three]),
+            a:      [1,2,3,4,5].dv(:a, [:two,:one,:three, :four, :five])
+          },
+            order: [:a, :b]
+          )
+
+        expect(df).to eq(DaruLite::DataFrame.new({
+            b: [14,13,12,15,11].dv(:b, [:five, :four, :one, :three, :two]),
+            a:      [5,4,2,3,1].dv(:a, [:five, :four, :one, :three, :two])
+          }, order: [:a, :b])
+        )
+      end
+
+      it "adds nil values for missing indexes and aligns by index" do
+        df = DaruLite::DataFrame.new({
+                 b: [11,12,13,14,15].dv(:b, [:two, :one, :four, :five, :three]),
+                 a: [1,2,3]         .dv(:a, [:two,:one,:three])
+               },
+               order: [:a, :b]
+             )
+
+        expect(df).to eq(DaruLite::DataFrame.new({
+            b: [14,13,12,15,11].dv(:b, [:five, :four, :one, :three, :two]),
+            a:  [nil,nil,2,3,1].dv(:a, [:five, :four, :one, :three, :two])
+          },
+          order: [:a, :b])
+        )
+      end
+
+      it "adds nils in first vector when other vectors have many extra indexes" do
+        df = DaruLite::DataFrame.new({
+            b: [11]                .dv(nil, [:one]),
+            a: [1,2,3]             .dv(nil, [:one, :two, :three]),
+            c: [11,22,33,44,55]    .dv(nil, [:one, :two, :three, :four, :five]),
+            d: [49,69,89,99,108,44].dv(nil, [:one, :two, :three, :four, :five, :six])
+          }, order: [:a, :b, :c, :d],
+          index: [:one, :two, :three, :four, :five, :six])
+
+        expect(df).to eq(DaruLite::DataFrame.new({
+            b: [11,nil,nil,nil,nil,nil].dv(nil, [:one, :two, :three, :four, :five, :six]),
+            a: [1,2,3,nil,nil,nil]     .dv(nil, [:one, :two, :three, :four, :five, :six]),
+            c: [11,22,33,44,55,nil]    .dv(nil, [:one, :two, :three, :four, :five, :six]),
+            d: [49,69,89,99,108,44]    .dv(nil, [:one, :two, :three, :four, :five, :six])
+          }, order: [:a, :b, :c, :d],
+          index: [:one, :two, :three, :four, :five, :six])
+        )
+      end
+
+      it "correctly matches the supplied DataFrame index with the individual vector indexes" do
+        df = DaruLite::DataFrame.new({
+            b: [11,12,13] .dv(nil, [:one, :bleh, :blah]),
+            a: [1,2,3,4,5].dv(nil, [:one, :two, :booh, :baah, :three]),
+            c: [11,22,33,44,55].dv(nil, [0,1,3,:three, :two])
+          }, order: [:a, :b, :c], index: [:one, :two, :three])
+
+        expect(df).to eq(DaruLite::DataFrame.new({
+            b: [11,nil,nil].dv(nil, [:one, :two, :three]),
+            a: [1,2,5]     .dv(nil, [:one, :two, :three]),
+            c: [nil,55,44] .dv(nil, [:one, :two, :three]),
+          },
+          order: [:a, :b, :c], index: [:one, :two, :three]
+          )
+        )
+      end
+
+      it "completes incomplete vectors" 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, :c])
+
+        expect(df.vectors).to eq([:a,:c,:b].to_index)
+      end
+
+      it "does not copy vectors when clone: false" do
+        a = DaruLite::Vector.new([1,2,3,4,5])
+        b = DaruLite::Vector.new([1,2,3,4,5])
+        c = DaruLite::Vector.new([1,2,3,4,5])
+        df = DaruLite::DataFrame.new({a: a, b: b, c: c}, clone: false)
+
+        expect(df[:a].object_id).to eq(a.object_id)
+        expect(df[:b].object_id).to eq(b.object_id)
+        expect(df[:c].object_id).to eq(c.object_id)
+      end
+
+      it "allows creation of empty dataframe with only order" do
+        df = DaruLite::DataFrame.new({}, order: [:a, :b, :c])
+        df[:a] = DaruLite::Vector.new([1,2,3,4,5,6])
+
+        expect(df.size).to eq(6)
+        expect(df[:a]).to eq(DaruLite::Vector.new([1,2,3,4,5,6]))
+        expect(df[:b]).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil]))
+        expect(df[:c]).to eq(DaruLite::Vector.new([nil,nil,nil,nil,nil,nil]))
+      end
+
+      it "allows creation of dataframe without specifying order or index" do
+        df = DaruLite::DataFrame.new({})
+        df[:a] = DaruLite::Vector.new([1,2,3,4,5])
+
+        expect(df.size)        .to eq(5)
+        expect(df.index.to_a)  .to eq([0,1,2,3,4])
+        expect(df.vectors.to_a).to eq([:a])
+        expect(df[:a])         .to eq(DaruLite::Vector.new([1,2,3,4,5]))
+      end
+
+      it "allows creation of dataframe with a default order" do
+        arr_of_arrs_df    = DaruLite::DataFrame.new([[1,2,3], [4,5,6], [7,8,9]])
+        arr_of_vectors_df = DaruLite::DataFrame.new([DaruLite::Vector.new([1,2,3]), DaruLite::Vector.new([4,5,6]), DaruLite::Vector.new([7,8,9])])
+
+        expect(arr_of_arrs_df.vectors.to_a).to eq([0,1,2])
+        expect(arr_of_vectors_df.vectors.to_a).to eq([0,1,2])
+      end
+
+      it "raises error for incomplete DataFrame index" do
+        expect {
+          df = 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])
+        }.to raise_error
+      end
+
+      it "raises error for unequal sized vectors/arrays" do
+        expect {
+          df = DaruLite::DataFrame.new({b: [11,12,13], a: [1,2,3,4,5],
+            c: [11,22,33,44,55]}, order: [:a, :b, :c],
+            index: [:one, :two, :three])
+        }.to raise_error
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      it "creates empty DataFrame" do
+        df = DaruLite::DataFrame.new({}, order: @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))
+      end
+
+      it "creates from Array of Hashes" do
+        # TODO
+      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)
+
+        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)
+        }.to raise_error
+      end
+
+      it "aligns MultiIndexes properly" do
+        pending
+        mi_a = @order_mi
+        mi_b = DaruLite::MultiIndex.from_tuples([
+          [:b,:one,:foo],
+          [:a,:one,:bar],
+          [:b,:two,:foo],
+          [:a,:one,:baz]
+        ])
+        mi_sorted = DaruLite::MultiIndex.from_tuples([
+          [:a, :one, :bar],
+          [:a, :one, :baz],
+          [:b, :one, :foo],
+          [:b, :two, :foo]
+        ])
+        order = DaruLite::MultiIndex.from_tuples([
+          [:pee, :que],
+          [:pee, :poo]
+        ])
+        a  = DaruLite::Vector.new([1,2,3,4], index: mi_a)
+        b  = DaruLite::Vector.new([11,12,13,14], index: mi_b)
+        df = DaruLite::DataFrame.new([b,a], order: order)
+
+        expect(df).to eq(DaruLite::DataFrame.new({
+          [:pee, :que] => DaruLite::Vector.new([1,2,4,3], index: mi_sorted),
+          [:pee, :poo] => DaruLite::Vector.new([12,14,11,13], index: mi_sorted)
+          }, order: order_mi))
+      end
+
+      it "adds nils in case of missing values" do
+        # TODO
+      end
+
+      it "matches individual vector indexing with supplied DataFrame index" do
+        # TODO
+      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 "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],
+      'b' => [5, 4, 3, 2, 1]
+    }, index: 11..15)}
+
+    context 'get vector' do
+      context 'by string' do
+        subject { df.b }
+
+        it { is_expected.to be_a DaruLite::Vector }
+        its(:to_a) { is_expected.to eq [5, 4, 3, 2, 1] }
+        its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
+      end
+
+      context 'by symbol' do
+        subject { df.a }
+
+        it { is_expected.to be_a DaruLite::Vector }
+        its(:to_a) { is_expected.to eq [1, 2, 3, 4, 5] }
+        its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
+      end
+    end
+
+    context 'set existing vector' do
+      context 'by string' do
+        before { df.b = [:a, :b, :c, :d, :e] }
+        subject { df }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:'vectors.to_a') { is_expected.to eq [:a, 'b'] }
+        its(:'b.to_a') { is_expected.to eq [:a, :b, :c, :d, :e] }
+        its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
+      end
+
+      context 'by symbol' do
+        before { df.a = [:a, :b, :c, :d, :e] }
+        subject { df }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:'vectors.to_a') { is_expected.to eq [:a, 'b'] }
+        its(:'a.to_a') { is_expected.to eq [:a, :b, :c, :d, :e] }
+        its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
+      end
+    end
+
+    context 'set new vector' do
+      before { df.c = [5, 5, 5, 5, 5] }
+      subject { df }
+
+      it { is_expected.to be_a DaruLite::DataFrame }
+      its(:'vectors.to_a') { is_expected.to eq [:a, 'b', :c] }
+      its(:'c.to_a') { is_expected.to eq [5, 5, 5, 5, 5] }
+      its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 15] }
+    end
+
+    context 'reference invalid vector' do
+      it { expect { df.d }.to raise_error NoMethodError }
+    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] }
+      let(:df) do
+        DaruLite::DataFrame.new({
+          a: 1..3,
+          b: 'a'..'c'
+        }, index: idx)
+      end
+
+      context "single position" do
+        subject { df.row.at 1 }
+
+        it { is_expected.to be_a DaruLite::Vector }
+        its(:size) { is_expected.to eq 2 }
+        its(:to_a) { is_expected.to eq [2, 'b'] }
+        its(:'index.to_a') { is_expected.to eq [:a, :b] }
+      end
+
+      context "multiple positions" do
+        subject { df.row.at 0, 2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 2 }
+        its(:'index.to_a') { is_expected.to eq [1, :c] }
+        its(:'a.to_a') { is_expected.to eq [1, 3] }
+        its(:'b.to_a') { is_expected.to eq ['a', 'c'] }
+      end
+
+      context "invalid position" do
+        it { expect { df.row.at 3 }.to raise_error IndexError }
+      end
+
+      context "invalid positions" do
+        it { expect { df.row.at 2, 3 }.to raise_error IndexError }
+      end
+
+      context "range" do
+        subject { df.row.at 0..1 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 2 }
+        its(:'index.to_a') { is_expected.to eq [1, 0] }
+        its(:'a.to_a') { is_expected.to eq [1, 2] }
+        its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
+      end
+
+      context "range with negative end" do
+        subject { df.row.at 0..-2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 2 }
+        its(:'index.to_a') { is_expected.to eq [1, 0] }
+        its(:'a.to_a') { is_expected.to eq [1, 2] }
+        its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
+      end
+
+      context "range with single element" do
+        subject { df.row.at 0..0 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 1 }
+        its(:'index.to_a') { is_expected.to eq [1] }
+        its(:'a.to_a') { is_expected.to eq [1] }
+        its(:'b.to_a') { is_expected.to eq ['a'] }
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      let (:idx) do
+        DaruLite::MultiIndex.from_tuples [
+          [:a,:one,:bar],
+          [:a,:one,:baz],
+          [:b,:two,:bar],
+          [:a,:two,:baz],
+        ]
+      end
+      let (:df) do
+        DaruLite::DataFrame.new({
+          a: 1..4,
+          b: 'a'..'d'
+        }, index: idx )
+      end
+
+      context "single position" do
+        subject { df.row.at 1 }
+
+        it { is_expected.to be_a DaruLite::Vector }
+        its(:size) { is_expected.to eq 2 }
+        its(:to_a) { is_expected.to eq [2, 'b'] }
+        its(:'index.to_a') { is_expected.to eq [:a, :b] }
+      end
+
+      context "multiple positions" do
+        subject { df.row.at 0, 2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 2 }
+        its(:'index.to_a') { is_expected.to eq [[:a, :one, :bar],
+          [:b, :two, :bar]] }
+        its(:'a.to_a') { is_expected.to eq [1, 3] }
+        its(:'a.index.to_a') { is_expected.to eq [[:a, :one, :bar],
+          [:b, :two, :bar]] }
+        its(:'b.to_a') { is_expected.to eq ['a', 'c'] }
+      end
+
+      context "invalid position" do
+        it { expect { df.row.at 4 }.to raise_error IndexError }
+      end
+
+      context "invalid positions" do
+        it { expect { df.row.at 3, 4 }.to raise_error IndexError }
+      end
+
+      context "range" do
+        subject { df.row.at 0..1 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 2 }
+        its(:'index.to_a') { is_expected.to eq [[:a, :one, :bar],
+          [:a, :one, :baz]] }
+        its(:'a.to_a') { is_expected.to eq [1, 2] }
+        its(:'a.index.to_a') { is_expected.to eq [[:a, :one, :bar],
+          [:a, :one, :baz]] }
+        its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
+      end
+
+      context "range with negative end" do
+        subject { df.row.at 0..-3 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 2 }
+        its(:'index.to_a') { is_expected.to eq [[:a, :one, :bar],
+          [:a, :one, :baz]] }
+        its(:'a.to_a') { is_expected.to eq [1, 2] }
+        its(:'a.index.to_a') { is_expected.to eq [[:a, :one, :bar],
+          [:a, :one, :baz]] }
+        its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
+      end
+
+      context " range with single element" do
+        subject { df.row.at 0..0 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 1 }
+        its(:'index.to_a') { is_expected.to eq [[:a, :one, :bar]] }
+        its(:'a.to_a') { is_expected.to eq [1] }
+        its(:'a.index.to_a') { is_expected.to eq [[:a, :one, :bar]] }
+        its(:'b.to_a') { is_expected.to eq ['a'] }
+      end
+    end
+
+    context DaruLite::CategoricalIndex do
+      let (:idx) { DaruLite::CategoricalIndex.new [:a, 1, 1, :a, :c] }
+      let (:df)  do
+        DaruLite::DataFrame.new({
+          a: 1..5,
+          b: 'a'..'e'
+        }, index: idx )
+      end
+
+      context "single positional index" do
+        subject { df.row.at 1 }
+
+        it { is_expected.to be_a DaruLite::Vector }
+        its(:size) { is_expected.to eq 2 }
+        its(:to_a) { is_expected.to eq [2, 'b'] }
+        its(:'index.to_a') { is_expected.to eq [:a, :b] }
+      end
+
+      context "multiple positional indexes" do
+        subject { df.row.at 0, 2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 2 }
+        its(:'index.to_a') { is_expected.to eq [:a, 1] }
+        its(:'a.to_a') { is_expected.to eq [1, 3] }
+        its(:'a.index.to_a') { is_expected.to eq [:a, 1] }
+        its(:'b.to_a') { is_expected.to eq ['a', 'c'] }
+        its(:'b.index.to_a') { is_expected.to eq [:a, 1] }
+      end
+
+      context "invalid position" do
+        it { expect { df.at 5 }.to raise_error IndexError }
+      end
+
+      context "invalid positions" do
+        it { expect { df.at 4, 5 }.to raise_error IndexError }
+      end
+
+      context "range" do
+        subject { df.row.at 0..1 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 2 }
+        its(:'index.to_a') { is_expected.to eq [:a, 1] }
+        its(:'a.to_a') { is_expected.to eq [1, 2] }
+        its(:'a.index.to_a') { is_expected.to eq [:a, 1] }
+        its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
+        its(:'b.index.to_a') { is_expected.to eq [:a, 1] }
+      end
+
+      context "range with negative end" do
+        subject { df.row.at 0..-4 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 2 }
+        its(:'index.to_a') { is_expected.to eq [:a, 1] }
+        its(:'a.to_a') { is_expected.to eq [1, 2] }
+        its(:'a.index.to_a') { is_expected.to eq [:a, 1] }
+        its(:'b.to_a') { is_expected.to eq ['a', 'b'] }
+        its(:'b.index.to_a') { is_expected.to eq [:a, 1] }
+      end
+
+      context " range with single element" do
+        subject { df.row.at 0..0 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:size) { is_expected.to eq 1 }
+        its(:'index.to_a') { is_expected.to eq [:a] }
+        its(:'a.to_a') { is_expected.to eq [1] }
+        its(:'a.index.to_a') { is_expected.to eq [:a] }
+        its(:'b.to_a') { is_expected.to eq ['a'] }
+        its(:'b.index.to_a') { is_expected.to eq [:a] }
+      end
+    end
+  end
+
+  context "#row.set_at" do
+    let(:df) do
+      DaruLite::DataFrame.new({
+        a: 1..3,
+        b: 'a'..'c'
+      })
+    end
+
+    context "single position" do
+      subject { df }
+      before { df.row.set_at [1], ['x', 'y'] }
+
+      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
+
+      it "returns a DataFrame when specifying numeric Range" do
+        expect(@df.row[0..2]).to eq(
+          DaruLite::DataFrame.new({b: [11,12,13], a: [1,2,3],
+            c: [11,22,33]}, order: [:a, :b, :c],
+            index: [:one, :two, :three])
+          )
+      end
+
+      it "returns a DataFrame when specifying symbolic Range" do
+        expect(@df.row[:one..:three]).to eq(
+          DaruLite::DataFrame.new({b: [11,12,13], a: [1,2,3],
+            c: [11,22,33]}, order: [:a, :b, :c],
+            index: [:one, :two, :three])
+          )
+      end
+
+      it "returns a row with the given index" do
+        expect(@df.row[:one]).to eq([1,11,11].dv(:one, [:a, :b, :c]))
+      end
+
+      it "returns a row with given Integer index" do
+        expect(@df.row[0]).to eq([1,11,11].dv(:one, [:a, :b, :c]))
+      end
+
+      it "returns a row with given Integer index for default index-less DataFrame" 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])
+
+        expect(df.row[0]).to eq([1,11,11].dv(nil, [:a, :b, :c]))
+        expect(df.row[3]).to eq([4,14,44].dv(nil, [:a, :b, :c]))
+      end
+
+      it "returns a row with given Integer index for numerical index DataFrame" 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: [1,2,3,4,5])
+
+        expect(df.row[0]).to eq([1,11,11].dv(nil, [:a, :b, :c]))
+        expect(df.row[3]).to eq([3,13,33].dv(nil, [:a, :b, :c]))
+      end
+    end
+
+    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))
+      end
+
+      it "returns a DataFrame whecn specifying numeric range" do
+        sub_index = DaruLite::MultiIndex.from_tuples([
+          [:a,:one,:bar],
+          [:a,:one,:baz]
+        ])
+
+        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))
+      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))
+      end
+
+      it "returns DataFrame when specifying first layer of MultiIndex" do
+        sub_index = DaruLite::MultiIndex.from_tuples([
+          [:one,:bar],
+          [:one,:baz],
+          [:two,:foo],
+          [:two,:bar]
+        ])
+        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))
+      end
+
+      it "returns DataFrame when specifying first and second layer of MultiIndex" do
+        sub_index = DaruLite::MultiIndex.from_tuples([
+          [:bar],
+          [:baz]
+        ])
+        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))
+      end
+    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 "single category" do
+        context "multiple instances" do
+          subject { df.row[:a] }
+
+          it { is_expected.to be_a DaruLite::DataFrame }
+          its(:index) { is_expected.to eq DaruLite::CategoricalIndex.new [:a, :a] }
+          its(:vectors) { is_expected.to eq DaruLite::Index.new [:a, :b] }
+          its(:a) { DaruLite::Vector.new ['a', 'c'] }
+          its(:b) { DaruLite::Vector.new [1, 3] }
+        end
+
+        context "single instance" do
+          subject { df.row[:c] }
+
+          it { is_expected.to be_a DaruLite::Vector }
+          its(:index) { is_expected.to eq DaruLite::Index.new [:a, :b] }
+          its(:to_a) { is_expected.to eq ['e', 5] }
+        end
+      end
+
+      context "multiple categories" do
+        subject { df.row[:a, 1] }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:index) { is_expected.to eq DaruLite::CategoricalIndex.new(
+          [:a, 1, :a, 1 ]) }
+        its(:vectors) { is_expected.to eq DaruLite::Index.new [:a, :b] }
+        its(:a) { DaruLite::Vector.new ['a', 'c', 'b', 'd'] }
+        its(:b) { DaruLite::Vector.new [1, 3, 2, 4] }
+      end
+
+      context "positional index" do
+        subject { df.row[0] }
+
+        it { is_expected.to be_a DaruLite::Vector }
+        its(:index) { is_expected.to eq DaruLite::Index.new [:a, :b] }
+        its(:to_a) { is_expected.to eq ['a', 1] }
+      end
+
+      context "invalid positional index" do
+        it { expect { df.row[5] }.to raise_error IndexError }
+      end
+
+      context "invalid category" do
+        it { expect { df.row[:d] }.to raise_error IndexError }
+      end
+    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]},
+        order: [:a, :b], index: [:one, :two, :three, :four, :five])
+
+      b = 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(a).to eq(b)
+    end
+  end
+
+  context '#rename' do
+    subject { @data_frame.rename 'other' }
+
+    it { is_expected.to be_a DaruLite::DataFrame }
+    its(:name) { is_expected.to eq 'other' }
+  end
+
+  context "#dup" 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)
+
+        @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
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      it "duplicates with multi index" do
+        clo = @df_mi.dup
+
+        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)
+      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 '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] }
+    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] }
+    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] }
+    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 [] }
+    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]
+      })
+    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] }
+    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])
+    end
+
+    it "overwrites vectors if the new name already exists" do
+      saved_vector = @df[:a].dup
+
+      @df.rename_vectors :a => :b
+      expect(@df.vectors.to_a).to eq([:b, :c])
+      expect(@df[:b]).to eq saved_vector
+    end
+
+    it "makes no changes if the old and new names are the same" do
+      saved_vector = @df[:a].dup
+
+      @df.rename_vectors :a => :a
+      expect(@df.vectors.to_a).to eq([:a, :b, :c])
+      expect(@df[:a]).to eq saved_vector
+    end
+  end
+
+  context "#add_level_to_vectors" do
+    subject { df.add_level_to_vectors(top_level_label) }
+
+    let(:df) do
+      DaruLite::DataFrame.new({
+        a: [1, 2, 3, 4, 5],
+        b: [11, 22, 33, 44, 55],
+        c: %w(a b c d e)
+      })
+    end
+    let(:top_level_label) { :percentages }
+    let(:expected_index) do
+      DaruLite::MultiIndex.from_tuples([
+        [:percentages, :a], [:percentages, :b],[:percentages, :c],
+      ])
+    end
+
+    it 'returns expected Multi::Index' do
+      expect(subject).to eq(expected_index)
+    end
+
+    it 'updates dataframe vectors to the expected Multi::Index' do
+      expect { subject }.to change { df.vectors }.to(expected_index)
+    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({
+          one: [1,11,11],
+          two: [2,12,22],
+          three: [3,13,33],
+          four: [4,14,44],
+          five: [5,15,55]
+          }, 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
+
+  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]))
+    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 }
+    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])
+    end
+  end
+
+  context "#add_vectors_by_split_recode" do
+    before do
+      @ds = 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 "" do
+      @ds.add_vectors_by_split_recode(:a1, '_')
+      expect(@ds.vectors.to_a)    .to eq([:id, :name, :age, :city ,:a1, :a1_1, :a1_2, :a1_3])
+      expect(@ds[:a1_1].to_a).to eq([1, 0, 1, nil, 1])
+      expect(@ds[:a1_2].to_a).to eq([1, 1, 0, nil, 1])
+      expect(@ds[:a1_3].to_a).to eq([0, 1, 0, nil, 1])
+    end
+  end
+
+  context "#add_vectors_by_split" do
+    before do
+      @ds = 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 "" do
+      @ds.add_vectors_by_split(:a1, '_')
+      expect(@ds.vectors.to_a).to eq([:id, :name, :age, :city, :a1, :a1_a, :a1_b, :a1_c])
+      expect(@ds[:a1_a].to_a).to eq([1, 0, 1, nil, 1])
+      expect(@ds[:a1_b].to_a).to eq([1, 1, 0, nil, 1])
+      expect(@ds[:a1_c].to_a).to eq([0, 1, 0, nil, 1])
+    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)
+      v2 = DaruLite::Vector.new %w(a b c a b c a b c)
+      v3 = DaruLite::Vector.new [0, 1, 0, 0, 1, 1, 0, 0, 1]
+      df = DaruLite::DataFrame.crosstab_by_assignation(v1, v2, v3)
+
+      expect(df[:_id].type).to eq(:object)
+      expect(df['a'].type).to eq(:numeric)
+      expect(df['b'].type).to eq(:numeric)
+
+      ev_id = DaruLite::Vector.new %w(a b c)
+      ev_a  = DaruLite::Vector.new [0, 0, 0]
+      ev_b  = DaruLite::Vector.new [1, 1, 0]
+      ev_c  = DaruLite::Vector.new [0, 1, 1]
+      df2 = DaruLite::DataFrame.new({
+        :_id => ev_id, 'a' => ev_a, 'b' => ev_b, 'c' => ev_c },
+        order: ['a', 'b', 'c', :_id])
+
+      expect(df2).to eq(df)
+    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 }
+
+    context 'empty' do
+      let(:df) { DaruLite::DataFrame.new({}, order: %w[a b c])}
+      it { is_expected.to eq %Q{
+        |#<DaruLite::DataFrame(0x3)>
+        |   a   b   c
+      }.unindent}
+    end
+
+    context 'simple' do
+      let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]}, name: 'test')}
+      it { should == %Q{
+        |#<DaruLite::DataFrame: test (3x3)>
+        |       a   b   c
+        |   0   1   3   6
+        |   1   2   4   7
+        |   2   3   5   8
+       }.unindent}
+    end
+
+    context 'if index name is set' do
+      context 'single index with name' do
+        let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]},
+        name: 'test')}
+        before { df.index.name = 'index_name' }
+        it { should == %Q{
+          |#<DaruLite::DataFrame: test (3x3)>
+          | index_name          a          b          c
+          |          0          1          3          6
+          |          1          2          4          7
+          |          2          3          5          8
+         }.unindent}
+      end
+
+      context 'MultiIndex with name' do
+        let(:mi) { DaruLite::MultiIndex.new(
+                levels: [[:a,:b,:c], [:one, :two]],
+                labels: [[0,0,1,1,2,2], [0,1,0,1,0,1]], name: ['s1', 's2']) }
+        let(:df) { DaruLite::DataFrame.new({
+          a: [11, 12, 13, 14, 15, 16], b: [21, 22, 23, 24, 25, 26]},
+            name: 'test', index: mi)}
+        it { should == %Q{
+          |#<DaruLite::DataFrame: test (6x2)>
+          |  s1  s2   a   b
+          |   a one  11  21
+          |     two  12  22
+          |   b one  13  23
+          |     two  14  24
+          |   c one  15  25
+          |     two  16  26
+         }.unindent}
+      end
+
+    end
+
+    context 'no name' do
+      let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]})}
+      it { should == %Q{
+        |#<DaruLite::DataFrame(3x3)>
+        |       a   b   c
+        |   0   1   3   6
+        |   1   2   4   7
+        |   2   3   5   8
+       }.unindent}
+    end
+
+    context 'with nils' do
+      let(:df) { DaruLite::DataFrame.new({a: [1,nil,3], b: [3,4,5], c: [6,7,nil]}, name: 'test')}
+      it { is_expected.to eq %Q{
+        |#<DaruLite::DataFrame: test (3x3)>
+        |       a   b   c
+        |   0   1   3   6
+        |   1 nil   4   7
+        |   2   3   5 nil
+       }.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{
+        |#<DaruLite::DataFrame: test (60x3)>
+        |       a   b   c
+        |   0   1   1   1
+        |   1   1   1   1
+        |   2   1   1   1
+        |   3   1   1   1
+        |   4   1   1   1
+        |   5   1   1   1
+        |   6   1   1   1
+        |   7   1   1   1
+        |   8   1   1   1
+        |   9   1   1   1
+        |  10   1   1   1
+        |  11   1   1   1
+        |  12   1   1   1
+        |  13   1   1   1
+        |  14   1   1   1
+        |  15   1   1   1
+        |  16   1   1   1
+        |  17   1   1   1
+        |  18   1   1   1
+        |  19   1   1   1
+        |  20   1   1   1
+        |  21   1   1   1
+        |  22   1   1   1
+        |  23   1   1   1
+        |  24   1   1   1
+        |  25   1   1   1
+        |  26   1   1   1
+        |  27   1   1   1
+        |  28   1   1   1
+        |  29   1   1   1
+        | ... ... ... ...
+       }.unindent}
+    end
+
+    context 'long data lines' do
+      let(:df) { DaruLite::DataFrame.new({a: [1,2,3], b: [4,5,6], c: ['this is ridiculously long',nil,nil]}, name: 'test')}
+      it { is_expected.to eq %Q{
+        |#<DaruLite::DataFrame: test (3x3)>
+        |                     a          b          c
+        |          0          1          4 this is ri
+        |          1          2          5        nil
+        |          2          3          6        nil
+       }.unindent}
+    end
+
+    context 'index is a MultiIndex' do
+      let(:df) {
+        DaruLite::DataFrame.new(
+          {
+            a:   [1,2,3,4,5,6,7],
+            b: %w[a b c d e f g]
+          }, index: DaruLite::MultiIndex.from_tuples([
+                %w[foo one],
+                %w[foo two],
+                %w[foo three],
+                %w[bar one],
+                %w[bar two],
+                %w[bar three],
+                %w[baz one],
+             ]),
+             name: 'test'
+        )
+      }
+
+      it { is_expected.to eq %Q{
+        |#<DaruLite::DataFrame: test (7x2)>
+        |                 a     b
+        |   foo   one     1     a
+        |         two     2     b
+        |       three     3     c
+        |   bar   one     4     d
+        |         two     5     e
+        |       three     6     f
+        |   baz   one     7     g
+      }.unindent}
+    end
+
+    context 'vectors is a MultiIndex' do
+    end
+
+    context 'spacing and threshold settings' 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] ) }
+
+    it 'raise error when vector is missing from dataframe' do
+      expect { df[:c] }.to raise_error(IndexError, /Specified vector c does not exist/)
+    end
+  end
+
+  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?