daru 0.1.3.1 → 0.1.4

data/spec/dataframe_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper.rb'
-
 describe Daru::DataFrame do
   before :each do
     @data_frame = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
@@ -66,6 +64,33 @@ describe Daru::DataFrame do
         expect(df.vectors)    .to eq(Daru::Index.new [:a,:b,:c,:d,:e])
         expect(df[:a]) .to eq(Daru::Vector.new [1,1,1,1])
       end
+
+      it 'derives index & order from arrays' do
+        df = Daru::DataFrame.rows @rows
+        expect(df.index)    .to eq(Daru::Index.new [0,1,2,3])
+        expect(df.vectors)  .to eq(Daru::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| Daru::Vector.new r, index: [:a,:b,:c,:d,:e], name: n }
+        df = Daru::DataFrame.rows rows
+        expect(df.index)    .to eq(Daru::Index.new %w[w x y z])
+        expect(df.vectors)  .to eq(Daru::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| Daru::Vector.new r, index: [:a,:b,:c,:d,:e], name: n }
+        df = Daru::DataFrame.rows rows
+        expect(df.index)    .to eq(Daru::Index.new %w[w_1 w_2 y z])
+        expect(df.vectors)  .to eq(Daru::Index.new [:a,:b,:c,:d,:e])
+      end
+
+      it 'behaves, when vectors are unnamed' do
+        rows = @rows.map { |r| Daru::Vector.new r, index: [:a,:b,:c,:d,:e] }
+        df = Daru::DataFrame.rows rows
+        expect(df.index)    .to eq(Daru::Index.new [0,1,2,3])
+        expect(df.vectors)  .to eq(Daru::Index.new [:a,:b,:c,:d,:e])
+      end
     end
 
     context Daru::MultiIndex do
@@ -133,7 +158,7 @@ describe Daru::DataFrame do
       end
 
       it "initializes from a Hash of Vectors" do
-        va = Daru::Vector.new([1,2,3,4,5], metadata: { cdc_type: 2 }, index: [:one, :two, :three, :four, :five])
+        va = Daru::Vector.new([1,2,3,4,5], index: [:one, :two, :three, :four, :five])
         vb = Daru::Vector.new([11,12,13,14,15], index: [:one, :two, :three, :four, :five])
 
         df = Daru::DataFrame.new({ b: vb, a: va }, order: [:a, :b], index: [:one, :two, :three, :four, :five])
@@ -142,8 +167,6 @@ describe Daru::DataFrame do
         expect(df.vectors).to eq(Daru::Index.new [:a, :b])
         expect(df.a.class).to eq(Daru::Vector)
         expect(df.a)      .to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
-        expect(df.a.metadata).to eq({ cdc_type: 2 })
-        expect(df.b.metadata).to eq({})
       end
 
       it "initializes from an Array of Hashes" do
@@ -422,13 +445,6 @@ describe Daru::DataFrame do
         expect(@df[:a, :b]).to eq(temp)
       end
 
-      it "returns a DataFrame with metadata" do
-        @df[:a].metadata = "alpha"
-        @df[:b].metadata = "beta"
-        subset_df = @df[:a, :b]
-        expect([:a, :b].map { |v| subset_df[v].metadata }).to eq(["alpha", "beta"])
-      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
@@ -440,6 +456,11 @@ describe Daru::DataFrame do
           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 Daru::MultiIndex do
@@ -540,22 +561,6 @@ describe Daru::DataFrame do
         expect(df_empty[:b].name).to equal(:b)
       end
 
-      it "copies metadata when the target is a vector" do
-        vec = Daru::Vector.new(1.upto(@df.size), index: @df.index, metadata: { cdc_type: 2 })
-        @df[:woo] = vec.dup
-        expect(@df[:woo].metadata).to eq vec.metadata
-      end
-
-      it "doesn't delete metadata when the source is a dataframe with empty vectors" do
-        empty_df = Daru::DataFrame.new({
-          a: Daru::Vector.new([], metadata: 'alpha'),
-          b: Daru::Vector.new([], metadata: 'beta'),
-          })
-
-        empty_df[:c] = Daru::Vector.new(1.upto(3))
-        expect(empty_df[:a].metadata).to eq 'alpha'
-      end
-
       it "appends multiple vectors at a time" do
         # TODO
       end
@@ -606,6 +611,70 @@ describe Daru::DataFrame do
     end
   end
 
+  context '#method_missing' do
+    subject(:data_frame) {
+      Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
+        c: [11,22,33,44,55]}, order: [:a, :b, :c],
+        index: [:one, :two, :three, :four, :five])
+    }
+
+    context 'getting the vector' do
+      subject{
+        data_frame.a
+      }
+      it { is_expected.to eq [1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]) }
+    end
+
+    context 'setting existing vector' do
+      before{
+        data_frame.a = [100,200,300,400,500]
+      }
+      it { is_expected.to eq(Daru::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 'setting new vector' do
+      before{
+        data_frame.d = [100,200,300,400,500]
+      }
+      it { is_expected.to eq(Daru::DataFrame.new({
+            b: [11,12,13,14,15],
+            a: [1,2,3,4,5],
+            d: [100,200,300,400,500],
+            c: [11,22,33,44,55]}, order: [:a, :b, :c, :d],
+            index: [:one, :two, :three, :four, :five]))
+      }
+    end
+
+    context 'no vector found' do
+      it 'should raise' do
+        expect { data_frame.e }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  context '#add_vector' do
+    subject(:data_frame) {
+      Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
+        c: [11,22,33,44,55]}, order: [:a, :b, :c],
+        index: [:one, :two, :three, :four, :five])
+    }
+    before {
+      data_frame.add_vector :a, [100,200,300,400,500]
+    }
+
+    it { is_expected.to eq(Daru::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 "#row[]=" do
     context Daru::Index do
       before :each do
@@ -685,10 +754,578 @@ describe Daru::DataFrame do
 
     context Daru::MultiIndex do
       pending
+      # TO DO
+    end
+
+    context Daru::CategoricalIndex do
+      let(:idx) { Daru::CategoricalIndex.new [:a, 1, :a, 1, :c] }
+      let(:df) do
+        Daru::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 Daru::DataFrame }
+          its(:index) { is_expected.to eq idx }
+          its(:vectors) { is_expected.to eq Daru::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 Daru::DataFrame }
+          its(:index) { is_expected.to eq idx }
+          its(:vectors) { is_expected.to eq Daru::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 Daru::DataFrame }
+          its(:index) { is_expected.to eq idx }
+          its(:vectors) { is_expected.to eq Daru::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 Daru::Index do
+      let(:idx) { Daru::Index.new [1, 0, :c] }
+      let(:df) do
+        Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::MultiIndex do
+      let (:idx) do
+        Daru::MultiIndex.from_tuples [
+          [:a,:one,:bar],
+          [:a,:one,:baz],
+          [:b,:two,:bar],
+          [:a,:two,:baz],
+        ]
+      end
+      let (:df) do
+        Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::CategoricalIndex do
+      let (:idx) { Daru::CategoricalIndex.new [:a, 1, 1, :a, :c] }
+      let (:df)  do
+        Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::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
+      Daru::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 Daru::Index do
+      let(:idx) { Daru::Index.new [:a, :b, :c] }
+      let(:df) do
+        Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::MultiIndex do
+      let (:idx) do
+        Daru::MultiIndex.from_tuples [
+          [:a,:one,:bar],
+          [:a,:one,:baz],
+          [:b,:two,:bar],
+        ]
+      end
+      let(:df) do
+        Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::CategoricalIndex do
+      let (:idx) { Daru::CategoricalIndex.new [:a, 1, 1] }
+      let(:df) do
+        Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::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
+      Daru::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 "#row[]" do
     context Daru::Index do
       before :each do
         @df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
@@ -741,7 +1378,7 @@ describe Daru::DataFrame do
         expect(@df_mi.row[0]).to eq(Daru::Vector.new([11,1,11,1], index: @order_mi))
       end
 
-      it "returns a DataFrame when specifying numeric range" do
+      it "returns a DataFrame whecn specifying numeric range" do
         sub_index = Daru::MultiIndex.from_tuples([
           [:a,:one,:bar],
           [:a,:one,:baz]
@@ -787,9 +1424,97 @@ describe Daru::DataFrame do
         ], index: sub_index, order: @order_mi))
       end
     end
+
+    context Daru::CategoricalIndex do
+      let(:idx) { Daru::CategoricalIndex.new [:a, 1, :a, 1, :c] }
+      let(:df) do
+        Daru::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 Daru::DataFrame }
+          its(:index) { is_expected.to eq Daru::CategoricalIndex.new [:a, :a] }
+          its(:vectors) { is_expected.to eq Daru::Index.new [:a, :b] }
+          its(:a) { Daru::Vector.new ['a', 'c'] }
+          its(:b) { Daru::Vector.new [1, 3] }
+        end
+
+        context "single instance" do
+          subject { df.row[:c] }
+
+          it { is_expected.to be_a Daru::Vector }
+          its(:index) { is_expected.to eq Daru::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 Daru::DataFrame }
+        its(:index) { is_expected.to eq Daru::CategoricalIndex.new(
+          [:a, 1, :a, 1 ]) }
+        its(:vectors) { is_expected.to eq Daru::Index.new [:a, :b] }
+        its(:a) { Daru::Vector.new ['a', 'c', 'b', 'd'] }
+        its(:b) { Daru::Vector.new [1, 3, 2, 4] }
+      end
+
+      context "positional index" do
+        subject { df.row[0] }
+
+        it { is_expected.to be_a Daru::Vector }
+        its(:index) { is_expected.to eq Daru::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) {
+      Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
+        c: [11,22,33,44,55]}, order: [:a, :b, :c],
+        index: [:one, :two, :three, :four, :five])
+    }
+    context 'named' do
+      before {
+        data_frame.add_row [100,200,300], :six
+      }
+
+      it { is_expected.to eq(Daru::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(Daru::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
+
     it "allows adding rows after making empty DF by specfying only order" do
       df = Daru::DataFrame.new({}, order: [:a, :b, :c])
       df.add_row [1,2,3]
@@ -802,6 +1527,40 @@ describe Daru::DataFrame do
     end
   end
 
+  context "#first" do
+    it 'works' do
+      expect(@data_frame.first(2)).to eq(
+        Daru::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
+  end
+
+  context "#last" do
+    it 'works' do
+      expect(@data_frame.last(2)).to eq(
+        Daru::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 = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]},
@@ -814,6 +1573,13 @@ describe Daru::DataFrame do
     end
   end
 
+  context '#rename' do
+    subject { @data_frame.rename 'other' }
+
+    it { is_expected.to be_a Daru::DataFrame }
+    its(:name) { is_expected.to eq 'other' }
+  end
+
   context "#dup" do
     context Daru::Index do
       it "dups every data structure inside DataFrame" do
@@ -841,31 +1607,122 @@ describe Daru::DataFrame do
     end
   end
 
-  context "#dup_only_valid" do
-    before do
-      @missing_data_df = Daru::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]
+  context '#reject_values' do
+    let(:df) do
+      Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::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 Daru::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
+      Daru::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
-
-    it "dups rows with non-missing data only" do
-      df = Daru::DataFrame.new({
-        a: [2, 3, 4, 5],
-        b: [2, 3, 4, 5],
-        c: [2, 3, 4, 5]
-      }, index: [1,2,4,6])
-      expect(@missing_data_df.dup_only_valid).to eq(df)
-    end
-
-    it "dups only the specified vectors" do
-      df = Daru::DataFrame.new({
-        a: [2,3,4,5],
-        c: [2,3,4,5]
-      }, index: [1,2,4,6])
-      expect(@missing_data_df.dup_only_valid([:a, :c])).to eq(df)
-    end
+    before { subject.to_category :b }
+    
+    context 'replace nils only' do
+      before { subject.replace_values nil, 10 }
+      it { is_expected.to be_a Daru::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 Daru::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 Daru::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 Daru::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
 
   context "#clone" do
@@ -902,6 +1759,27 @@ describe Daru::DataFrame do
 
   end
 
+  context "#clone_only_valid" do
+    let(:df_with_missing) {
+      Daru::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) {
+      Daru::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(*Daru::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
@@ -912,6 +1790,19 @@ describe Daru::DataFrame do
     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 = []
@@ -964,6 +1855,10 @@ describe Daru::DataFrame 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
@@ -1108,8 +2003,23 @@ describe Daru::DataFrame do
     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(Daru::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 a modified DataFrame" 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
@@ -1122,6 +2032,21 @@ describe Daru::DataFrame do
     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(Daru::Vector)
+        row[:a] * row[:c]
+      end
+
+      expected = Daru::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 Daru::Index do
       it "deletes the specified vector" do
@@ -1208,6 +2133,13 @@ describe Daru::DataFrame do
 
         expect(a).to eq(Daru::DataFrame.new({a: [2], b: [3]}, order: [:a, :b], index: [1]))
       end
+
+      it "preserves names of vectors" do
+        df = Daru::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
 
@@ -1225,6 +2157,19 @@ describe Daru::DataFrame do
     end
   end
 
+  context "#filter" do
+    let(:df) { Daru::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 Daru::Index do
       it "converts DataFrame into array of hashes" do
@@ -1280,7 +2225,6 @@ describe Daru::DataFrame do
     context Daru::Index do
       before :each do
         @df = Daru::DataFrame.new({a: [5,1,-6,7,5,5], b: [-2,-1,5,3,9,1], c: ['a','aa','aaa','aaaa','aaaaa','aaaaaa']})
-        @df[:a].metadata = { cdc_type: 2 }
       end
 
       it "sorts according to given vector order (bang)" do
@@ -1302,17 +2246,115 @@ describe Daru::DataFrame do
           )
         expect(ans).to_not eq(@df)
       end
-
-      it "retains the vector metadata from the original dataframe" do
-        ans = @df.sort([:a])
-        expect(ans[:a].metadata).to eq({ cdc_type: 2 })
-      end
-
     end
 
     context Daru::MultiIndex do
       pending
     end
+
+    context Daru::CategoricalIndex do
+      let(:idx) { Daru::CategoricalIndex.new [:a, 1, :a, 1, :c] }
+      let(:df) do
+        Daru::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
@@ -1451,6 +2493,11 @@ describe Daru::DataFrame do
         @df.index = Daru::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 Daru::Index.new (1..5).to_a
+    end
   end
 
   context "#vectors=" do
@@ -1755,6 +2802,25 @@ describe Daru::DataFrame do
           ], order: agg_vectors, index: agg_index
         )
       )
+
+      agg_vectors = Daru::MultiIndex.from_tuples(
+        [
+          [:d, 'one'],
+          [:d, 'two'],
+          [:e, 'one'],
+          [:e, 'two']
+        ]
+      )
+      expect(@df.pivot_table(index: [:a], vectors: [:b], values: [:d, :e])).to eq(
+        Daru::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
@@ -1875,6 +2941,12 @@ describe Daru::DataFrame do
     end
   end
 
+  context '#to_df' do
+    it 'returns the dataframe' do
+      @data_frame.to_df == @data_frame
+    end
+  end
+
   context "#to_gsl" do
     it "converts to GSL::Matrix" do
       rows = [[1,2,3,4,5],[11,12,13,14,15],[11,22,33,44,55]].transpose
@@ -1904,6 +2976,16 @@ describe Daru::DataFrame do
 
       expect(ds1.merge(ds3)).to eq(exp)
     end
+
+    context "preserves type of vector names" do
+      let(:df1) { Daru::DataFrame.new({'a'=> [1, 2, 3]}) }
+      let(:df2) { Daru::DataFrame.new({:b=> [4, 5, 6]}) }
+      subject { df1.merge df2 }
+
+      it { is_expected.to be_a Daru::DataFrame }
+      it { expect(subject['a'].to_a).to eq [1, 2, 3] }
+      it { expect(subject[:b].to_a).to eq [4, 5, 6] }
+    end
   end
 
   context "#vector_by_calculation" do
@@ -1967,24 +3049,29 @@ describe Daru::DataFrame do
     end
   end
 
-
-  context "has_missing_data?" do
-    before do
-      a1 = Daru::Vector.new [1, nil, 3, 4, 5, nil]
-      a2 = Daru::Vector.new [10, nil, 20, 20, 20, 30]
-      b1 = Daru::Vector.new [nil, nil, 1, 1, 1, 2]
-      b2 = Daru::Vector.new [2, 2, 2, nil, 2, 3]
-      c  = Daru::Vector.new [nil, 2, 4, 2, 2, 2]
-      @df = Daru::DataFrame.new({ :a1 => a1, :a2 => a2, :b1 => b1, :b2 => b2, :c => c })
+  context '#include_values?' do
+    let(:df) do
+      Daru::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
-
-    it "returns true when missing data present" do
-      expect(@df.has_missing_data?).to eq(true)
+    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
-
-    it "returns false when no missing data prensent" do
-      a = @df.dup_only_valid
-      expect(a.has_missing_data?).to eq(false)
+    
+    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
 
@@ -2076,9 +3163,13 @@ describe Daru::DataFrame do
 
       dataf = @df.verify(t3, t1, t2)
       expect(dataf).to eq(exp1)
+    end
 
-      dataf = @df.verify(:id, t1, t2, t3)
-      expect(dataf).to eq(exp2)
+    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
 
@@ -2169,6 +3260,10 @@ describe Daru::DataFrame do
     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
@@ -2194,6 +3289,10 @@ describe Daru::DataFrame do
     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
@@ -2372,4 +3471,199 @@ describe Daru::DataFrame do
     end
 
   end
+
+  context '#inspect' do
+    subject { df.inspect }
+
+    context 'empty' do
+      let(:df) { Daru::DataFrame.new({}, order: %w[a b c])}
+      it { is_expected.to eq %Q{
+        |#<Daru::DataFrame(0x3)>
+        |   a   b   c
+      }.unindent}
+    end
+
+    context 'simple' do
+      let(:df) { Daru::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]}, name: 'test')}
+      it { should == %Q{
+        |#<Daru::DataFrame: test (3x3)>
+        |       a   b   c
+        |   0   1   3   6
+        |   1   2   4   7
+        |   2   3   5   8
+       }.unindent}
+    end
+
+    context 'no name' do
+      let(:df) { Daru::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]})}
+      it { should == %Q{
+        |#<Daru::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) { Daru::DataFrame.new({a: [1,nil,3], b: [3,4,5], c: [6,7,nil]}, name: 'test')}
+      it { is_expected.to eq %Q{
+        |#<Daru::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) { Daru::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{
+        |#<Daru::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
+        | ... ... ... ...
+       }.unindent}
+    end
+
+    context 'long data lines' do
+      let(:df) { Daru::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{
+        |#<Daru::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) {
+        Daru::DataFrame.new(
+          {
+            a:   [1,2,3,4,5,6,7],
+            b: %w[a b c d e f g]
+          }, index: Daru::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{
+        |#<Daru::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 something, despite of how reasonable you think it is' do
+      expect(@data_frame.to_s).to eq @data_frame.to_html
+    end
+  end
+
+  context '#to_json' do
+    let(:df) { Daru::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 '#create_sql' do
+    let(:df) { Daru::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
 end if mri?