daru 0.1.3.1 → 0.1.4

data/spec/vector_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper.rb'
-
 describe Daru::Vector do
   ALL_DTYPES.each do |dtype|
     describe dtype.to_s do
@@ -84,12 +82,6 @@ describe Daru::Vector do
           expect(dv.index.to_a).to eq(['a', 'b', :r, 0])
         end
 
-        it "accepts a metadata attribute" do
-          dv = Daru::Vector.new [1,2,3,4,5], metadata: { cdc_type: 2 }
-
-          expect(dv.metadata) .to eq({ cdc_type: 2 })
-        end
-
       end
 
       context ".new_with_size" do
@@ -129,7 +121,7 @@ describe Daru::Vector do
       context "#[]" do
         context Daru::Index do
           before :each do
-            @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, metadata: { cdc_type: 2 },
+            @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga,
               index: [:yoda, :anakin, :obi, :padme, :r2d2], dtype: dtype
           end
 
@@ -173,10 +165,6 @@ describe Daru::Vector do
             expect { @dv[:foo] }.to raise_error(IndexError)
             expect { @dv[:obi, :foo] }.to raise_error(IndexError)
           end
-
-          it "retains the original vector metadata" do
-            expect(@dv[:yoda, :anakin].metadata).to eq({ cdc_type: 2 })
-          end
         end
 
         context Daru::MultiIndex do
@@ -254,6 +242,266 @@ describe Daru::Vector do
             expect { @vector[:x, :one] }.to raise_error(IndexError)
           end
         end
+
+        context Daru::CategoricalIndex do
+          # before { skip }
+          context "non-numerical index" do
+            let (:idx) { Daru::CategoricalIndex.new [:a, :b, :a, :a, :c] }
+            let (:dv)  { Daru::Vector.new 'a'..'e', index: idx }
+
+            context "single category" do
+              context "multiple instances" do
+                subject { dv[:a] }
+
+                it { is_expected.to be_a Daru::Vector }
+                its(:size) { is_expected.to eq 3 }
+                its(:to_a) { is_expected.to eq  ['a', 'c', 'd'] }
+                its(:index) { is_expected.to eq(
+                  Daru::CategoricalIndex.new([:a, :a, :a])) }
+              end
+
+              context "single instance" do
+                subject { dv[:c] }
+
+                it { is_expected.to eq 'e' }
+              end
+            end
+
+            context "multiple categories" do
+              subject { dv[:a, :c] }
+
+              it { is_expected.to be_a Daru::Vector }
+              its(:size) { is_expected.to eq 4 }
+              its(:to_a) { is_expected.to eq  ['a', 'c', 'd', 'e'] }
+              its(:index) { is_expected.to eq(
+                Daru::CategoricalIndex.new([:a, :a, :a, :c])) }
+            end
+
+            context "multiple positional indexes" do
+              subject { dv[0, 1, 2] }
+
+              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(
+                Daru::CategoricalIndex.new([:a, :b, :a])) }
+            end
+
+            context "single positional index" do
+              subject { dv[1] }
+
+              it { is_expected.to eq 'b' }
+            end
+
+            context "invalid category" do
+              it { expect { dv[:x] }.to raise_error IndexError }
+            end
+
+            context "invalid positional index" do
+              it { expect { dv[30] }.to raise_error IndexError }
+            end
+          end
+
+          context "numerical index" do
+            let (:idx) { Daru::CategoricalIndex.new [1, 1, 2, 2, 3] }
+            let (:dv)  { Daru::Vector.new 'a'..'e', index: idx }
+
+            context "single category" do
+              context "multiple instances" do
+                subject { dv[1] }
+
+                it { is_expected.to be_a Daru::Vector }
+                its(:size) { is_expected.to eq 2 }
+                its(:to_a) { is_expected.to eq  ['a', 'b'] }
+                its(:index) { is_expected.to eq(
+                  Daru::CategoricalIndex.new([1, 1])) }
+              end
+
+              context "single instance" do
+                subject { dv[3] }
+
+                it { is_expected.to eq 'e' }
+              end
+            end
+          end
+        end
+      end
+
+      context "#at" do
+        context Daru::Index do
+          let (:idx) { Daru::Index.new [1, 0, :c] }
+          let (:dv) { Daru::Vector.new ['a', 'b', 'c'], index: idx }
+
+          context "single position" do
+            it { expect(dv.at 1).to eq 'b' }
+          end
+
+          context "multiple positions" do
+            subject { dv.at 0, 2 }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 2 }
+            its(:to_a) { is_expected.to eq ['a', 'c'] }
+            its(:'index.to_a') { is_expected.to eq [1, :c] }
+          end
+
+          context "invalid position" do
+            it { expect { dv.at 3 }.to raise_error IndexError }
+          end
+
+          context "invalid positions" do
+            it { expect { dv.at 2, 3 }.to raise_error IndexError }
+          end
+
+          context "range" do
+            subject { dv.at 0..1 }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 2 }
+            its(:to_a) { is_expected.to eq ['a', 'b'] }
+            its(:'index.to_a') { is_expected.to eq [1, 0] }
+          end
+
+          context "range with negative end" do
+            subject { dv.at 0..-2 }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 2 }
+            its(:to_a) { is_expected.to eq ['a', 'b'] }
+            its(:'index.to_a') { is_expected.to eq [1, 0] }
+          end
+
+          context "range with single element" do
+            subject { dv.at 0..0 }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 1 }
+            its(:to_a) { is_expected.to eq ['a'] }
+            its(:'index.to_a') { is_expected.to eq [1] }
+          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 (:dv) { Daru::Vector.new 1..4, index: idx }
+
+          context "single position" do
+            it { expect(dv.at 1).to eq 2 }
+          end
+
+          context "multiple positions" do
+            subject { dv.at 2, 3 }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 2 }
+            its(:to_a) { is_expected.to eq [3, 4] }
+            its(:'index.to_a') { is_expected.to eq [[:b, :two, :bar],
+              [:a, :two, :baz]] }
+          end
+
+          context "invalid position" do
+            it { expect { dv.at 4 }.to raise_error IndexError }
+          end
+
+          context "invalid positions" do
+            it { expect { dv.at 2, 4 }.to raise_error IndexError }
+          end
+
+          context "range" do
+            subject { dv.at 2..3 }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 2 }
+            its(:to_a) { is_expected.to eq [3, 4] }
+            its(:'index.to_a') { is_expected.to eq [[:b, :two, :bar],
+              [:a, :two, :baz]] }
+          end
+
+          context "range with negative end" do
+            subject { dv.at 2..-1 }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 2 }
+            its(:to_a) { is_expected.to eq [3, 4] }
+            its(:'index.to_a') { is_expected.to eq [[:b, :two, :bar],
+              [:a, :two, :baz]] }
+          end
+
+          context "range with single element" do
+            subject { dv.at 2..2 }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 1 }
+            its(:to_a) { is_expected.to eq [3] }
+            its(:'index.to_a') { is_expected.to eq [[:b, :two, :bar]] }
+          end
+        end
+
+        context Daru::CategoricalIndex do
+          let (:idx) { Daru::CategoricalIndex.new [:a, 1, 1, :a, :c] }
+          let (:dv)  { Daru::Vector.new 'a'..'e', index: idx }
+
+          context "multiple positional indexes" do
+            subject { dv.at 0, 1, 2 }
+
+            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(
+              Daru::CategoricalIndex.new([:a, 1, 1])) }
+          end
+
+          context "single positional index" do
+            subject { dv.at 1 }
+
+            it { is_expected.to eq 'b' }
+          end
+
+          context "invalid position" do
+            it { expect { dv.at 5 }.to raise_error IndexError }
+          end
+
+          context "invalid positions" do
+            it { expect { dv.at 2, 5 }.to raise_error IndexError }
+          end
+
+          context "range" do
+            subject { dv.at 0..2 }
+
+            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(
+              Daru::CategoricalIndex.new([:a, 1, 1])) }
+          end
+
+          context "range with negative end" do
+            subject { dv.at 0..-3 }
+
+            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(
+              Daru::CategoricalIndex.new([:a, 1, 1])) }
+          end
+
+          context "range with single element" do
+            subject { dv.at 0..0 }
+
+            it { is_expected.to be_a Daru::Vector }
+            its(:size) { is_expected.to eq 1 }
+            its(:to_a) { is_expected.to eq ['a'] }
+            its(:index) { is_expected.to eq(
+              Daru::CategoricalIndex.new([:a])) }
+          end
+        end
       end
 
       context "#[]=" do
@@ -339,6 +587,223 @@ describe Daru::Vector do
             expect(@vector).to eq(Daru::Vector.new([0,1,2,3,4,5,6,69,8,9,10,11],
               index: @multi_index, name: :precise_assignment, dtype: dtype))
           end
+
+          it "fails predictably on unknown index" do
+            expect { @vector[:d] = 69 }.to raise_error(IndexError)
+            expect { @vector[:b, :three] = 69 }.to raise_error(IndexError)
+            expect { @vector[:b, :two, :test] = 69 }.to raise_error(IndexError)
+          end
+        end
+
+        context Daru::CategoricalIndex do
+          context "non-numerical index" do
+            let (:idx) { Daru::CategoricalIndex.new [:a, :b, :a, :a, :c] }
+            let (:dv)  { Daru::Vector.new 'a'..'e', index: idx }
+
+            context "single category" do
+              context "multiple instances" do
+                subject { dv }
+                before { dv[:a] = 'x' }
+
+                its(:size) { is_expected.to eq 5 }
+                its(:to_a) { is_expected.to eq  ['x', 'b', 'x', 'x', 'e'] }
+                its(:index) { is_expected.to eq idx }
+              end
+
+              context "single instance" do
+                subject { dv }
+                before { dv[:b] = 'x' }
+
+                its(:size) { is_expected.to eq 5 }
+                its(:to_a) { is_expected.to eq  ['a', 'x', 'c', 'd', 'e'] }
+                its(:index) { is_expected.to eq idx }
+              end
+            end
+
+            context "multiple categories" do
+              subject { dv }
+              before { dv[:a, :c] = 'x' }
+
+              its(:size) { is_expected.to eq 5 }
+              its(:to_a) { is_expected.to eq  ['x', 'b', 'x', 'x', 'x'] }
+              its(:index) { is_expected.to eq idx }
+            end
+
+            context "multiple positional indexes" do
+              subject { dv }
+              before { dv[0, 1, 2] = 'x' }
+
+              its(:size) { is_expected.to eq 5 }
+              its(:to_a) { is_expected.to eq ['x', 'x', 'x', 'd', 'e'] }
+              its(:index) { is_expected.to eq idx }
+            end
+
+            context "single positional index" do
+              subject { dv }
+              before { dv[1] = 'x' }
+
+              its(:size) { is_expected.to eq 5 }
+              its(:to_a) { is_expected.to eq ['a', 'x', 'c', 'd', 'e'] }
+              its(:index) { is_expected.to eq idx }
+            end
+
+            context "invalid category" do
+              it { expect { dv[:x] = 'x' }.to raise_error IndexError }
+            end
+
+            context "invalid positional index" do
+              it { expect { dv[30] = 'x'}.to raise_error IndexError }
+            end
+          end
+
+          context "numerical index" do
+            let (:idx) { Daru::CategoricalIndex.new [1, 1, 2, 2, 3] }
+            let (:dv)  { Daru::Vector.new 'a'..'e', index: idx }
+
+            context "single category" do
+              subject { dv }
+              before { dv[1] = 'x' }
+
+              its(:size) { is_expected.to eq 5 }
+              its(:to_a) { is_expected.to eq ['x', 'x', 'c', 'd', 'e'] }
+              its(:index) { is_expected.to eq idx }
+            end
+
+            context "multiple categories" do
+              subject { dv }
+              before { dv[1, 2] = 'x' }
+
+              its(:size) { is_expected.to eq 5 }
+              its(:to_a) { is_expected.to eq ['x', 'x', 'x', 'x', 'e'] }
+              its(:index) { is_expected.to eq idx }
+            end
+          end
+        end
+      end
+
+      context "#set_at" do
+        context Daru::Index do
+          let (:idx) { Daru::Index.new [1, 0, :c] }
+          let (:dv) { Daru::Vector.new ['a', 'b', 'c'], index: idx }
+
+          context "single position" do
+            subject { dv }
+            before { dv.set_at [1], 'x' }
+
+            its(:to_a) { is_expected.to eq ['a', 'x', 'c'] }
+          end
+
+          context "multiple positions" do
+            subject { dv }
+            before { dv.set_at [0, 2], 'x' }
+
+            its(:to_a) { is_expected.to eq ['x', 'b', 'x'] }
+          end
+
+          context "invalid position" do
+            it { expect { dv.set_at [3], 'x' }.to raise_error IndexError }
+          end
+
+          context "invalid positions" do
+            it { expect { dv.set_at [2, 3], 'x' }.to raise_error IndexError }
+          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(:dv) { Daru::Vector.new 1..4, index: idx }
+
+          context "single position" do
+            subject { dv }
+            before { dv.set_at [1], 'x' }
+
+            its(:to_a) { is_expected.to eq [1, 'x', 3, 4] }
+          end
+
+          context "multiple positions" do
+            subject { dv }
+            before { dv.set_at [2, 3], 'x' }
+
+            its(:to_a) { is_expected.to eq [1, 2, 'x', 'x'] }
+          end
+
+          context "invalid position" do
+            it { expect { dv.set_at [4], 'x' }.to raise_error IndexError }
+          end
+
+          context "invalid positions" do
+            it { expect { dv.set_at [2, 4], 'x' }.to raise_error IndexError }
+          end
+        end
+
+        context Daru::CategoricalIndex do
+          let (:idx) { Daru::CategoricalIndex.new [:a, 1, 1, :a, :c] }
+          let (:dv)  { Daru::Vector.new 'a'..'e', index: idx }
+
+          context "multiple positional indexes" do
+            subject { dv }
+            before { dv.set_at [0, 1, 2], 'x' }
+
+            its(:to_a) { is_expected.to eq ['x', 'x', 'x', 'd', 'e'] }
+          end
+
+          context "single positional index" do
+            subject { dv }
+            before { dv.set_at [1], 'x' }
+
+            its(:to_a) { is_expected.to eq ['a', 'x', 'c', 'd', 'e'] }
+          end
+
+          context "invalid position" do
+            it { expect { dv.set_at [5], 'x' }.to raise_error IndexError }
+          end
+
+          context "invalid positions" do
+            it { expect { dv.set_at [2, 5], 'x' }.to raise_error IndexError }
+          end
+        end
+      end
+
+      context '#head' do
+        subject(:vector) do
+          Daru::Vector.new (1..20).to_a, dtype: dtype
+        end
+
+        it 'takes 10 by default' do
+          expect(vector.head).to eq Daru::Vector.new (1..10).to_a
+        end
+
+        it 'takes num if provided' do
+          expect(vector.head(3)).to eq Daru::Vector.new (1..3).to_a
+        end
+
+        it 'does not fail on too large num' do
+          expect(vector.head(3000)).to eq vector
+        end
+      end
+
+      context '#tail' do
+        subject(:vector) do
+          Daru::Vector.new (1..20).to_a, dtype: dtype
+        end
+
+        it 'takes 10 by default' do
+          expect(vector.tail).to eq Daru::Vector.new (11..20).to_a, index: (10..19).to_a
+        end
+
+        it 'takes num if provided' do
+          expect(vector.tail(3)).to eq Daru::Vector.new (18..20).to_a, index: (17..19).to_a
+        end
+
+        it 'does not fail on too large num' do
+          expect(vector.tail(3000)).to eq vector
         end
       end
 
@@ -446,6 +911,27 @@ describe Daru::Vector do
         end
       end
 
+      context "#to_df" do
+        let(:dv) { Daru::Vector.new(['a','b','c'], name: :my_dv, index: ['alpha', 'beta', 'gamma']) }
+        let(:df) { dv.to_df }
+
+        it 'is a dataframe' do
+          expect(df).to be_a Daru::DataFrame
+        end
+
+        it 'converts the vector to a single-vector dataframe' do
+          expect(df[:my_dv]).to eq dv
+        end
+
+        it 'has the same index as the original vector' do
+          expect(df.index).to eq dv.index
+        end
+
+        it 'has the same name as the vector' do
+          expect(df.name).to eq :my_dv
+        end
+      end
+
       context "#to_h" do
         context Daru::Index do
           it "returns the vector as a hash" do
@@ -477,17 +963,22 @@ describe Daru::Vector do
         end
       end
 
+      context "#to_json" do
+        subject(:vector) do
+          Daru::Vector.new [1,2,3,4,5], name: :a,
+              index: [:one, :two, :three, :four, :five], dtype: dtype
+        end
+
+        its(:to_json) { is_expected.to eq(vector.to_h.to_json) }
+      end
+
       context "#uniq" do
         before do
-          @v = Daru::Vector.new [1, 2, 2, 2.0, 3, 3.0], index:[:a, :b, :c, :d, :e, :f], metadata: { cdc_type: 2 }
+          @v = Daru::Vector.new [1, 2, 2, 2.0, 3, 3.0], index:[:a, :b, :c, :d, :e, :f]
         end
         it "keeps only unique values" do
           expect(@v.uniq).to eq(Daru::Vector.new [1, 2, 2.0, 3, 3.0], index: [:a, :b, :d, :e, :f])
         end
-
-        it "retains the original vector metadata" do
-          expect(@v.uniq.metadata).to eq({ cdc_type: 2 })
-        end
       end
 
       context "#cast" do
@@ -503,7 +994,7 @@ describe Daru::Vector do
       context "#sort" do
         context Daru::Index do
           before do
-            @dv = Daru::Vector.new [33,2,15,332,1], name: :dv, index: [:a, :b, :c, :d, :e], metadata: { cdc_type: 2 }
+            @dv = Daru::Vector.new [33,2,15,332,1], name: :dv, index: [:a, :b, :c, :d, :e]
           end
 
           it "sorts the vector with defaults and returns a new vector, preserving indexing" do
@@ -531,7 +1022,7 @@ describe Daru::Vector do
             with_nils = Daru::Vector.new [22,4,nil,111,nil,2]
 
             expect(with_nils.sort(ascending: false)).to eq(
-              Daru::Vector.new [nil,nil,111,22,4,2], index: [4,2,3,0,1,5])
+              Daru::Vector.new [111,22,4,2,nil,nil], index: [3,0,1,5,4,2])
           end
 
           it "correctly sorts vector in ascending order with non-numeric data and nils" do
@@ -545,11 +1036,7 @@ describe Daru::Vector do
             non_numeric = Daru::Vector.new ['a','b', nil, 'aa', '1234', nil]
 
             expect(non_numeric.sort(ascending: false)).to eq(
-              Daru::Vector.new [nil,nil,'b','aa','a','1234'], index: [5,2,1,3,0,4])
-          end
-
-          it "retains the original vector metadata" do
-            expect(@dv.sort.metadata).to eq({ cdc_type: 2 })
+              Daru::Vector.new ['b','aa','a','1234',nil,nil], index: [1,3,0,4,5,2])
           end
         end
 
@@ -602,6 +1089,79 @@ describe Daru::Vector do
               [0,22,44,-56,111], index: mi_abs, name: :sort_abs, dtype: dtype))
           end
         end
+
+        context Daru::CategoricalIndex do
+          let(:idx) { Daru::CategoricalIndex.new [:a, 1, :a, 1, :c] }
+          let(:dv_numeric) { Daru::Vector.new [4, 5, 3, 2, 1], index: idx }
+          let(:dv_string) { Daru::Vector.new ['xxxx', 'zzzzz', 'ccc', 'bb', 'a'], index: idx }
+          let(:dv_nil) { Daru::Vector.new [3, nil, 2, 1, -1], index: idx }
+
+          context "increasing order" do
+            context "numeric" do
+              subject { dv_numeric.sort }
+
+              its(:size) { is_expected.to eq 5 }
+              its(:to_a) { is_expected.to eq [1, 2, 3, 4, 5] }
+              its(:'index.to_a') { is_expected.to eq [:c, 1, :a, :a, 1] }
+            end
+
+            context "non-numeric" do
+              subject { dv_string.sort }
+
+              its(:size) { is_expected.to eq 5 }
+              its(:to_a) { is_expected.to eq ['a', 'bb', 'ccc', 'xxxx', 'zzzzz'] }
+              its(:'index.to_a') { is_expected.to eq [:c, 1, :a, :a, 1] }
+            end
+
+            context "block" do
+              subject { dv_string.sort { |a, b| a.length <=> b.length } }
+
+              its(:to_a) { is_expected.to eq ['a', 'bb', 'ccc', 'xxxx', 'zzzzz'] }
+              its(:'index.to_a') { is_expected.to eq [:c, 1, :a, :a, 1] }
+            end
+
+            context "nils" do
+              subject { dv_nil.sort }
+
+              its(:to_a) { is_expected.to eq [nil, -1, 1, 2, 3] }
+              its(:'index.to_a') { is_expected.to eq [1, :c, 1, :a, :a] }
+            end
+          end
+
+          context "decreasing order" do
+            context "numeric" do
+              subject { dv_numeric.sort(ascending: false) }
+
+              its(:size) { is_expected.to eq 5 }
+              its(:to_a) { is_expected.to eq [5, 4, 3, 2, 1] }
+              its(:'index.to_a') { is_expected.to eq [1, :a, :a, 1, :c] }
+            end
+
+            context "non-numeric" do
+              subject { dv_string.sort(ascending: false) }
+
+              its(:size) { is_expected.to eq 5 }
+              its(:to_a) { is_expected.to eq ['zzzzz', 'xxxx', 'ccc', 'bb', 'a'] }
+              its(:'index.to_a') { is_expected.to eq [1, :a, :a, 1, :c] }
+            end
+
+            context "block" do
+              subject do
+                dv_string.sort(ascending: false) { |a, b| a.length <=> b.length }
+              end
+
+              its(:to_a) { is_expected.to eq ['zzzzz', 'xxxx', 'ccc', 'bb', 'a'] }
+              its(:'index.to_a') { is_expected.to eq [1, :a, :a, 1, :c] }
+            end
+
+            context "nils" do
+              subject { dv_nil.sort(ascending: false) }
+
+              its(:to_a) { is_expected.to eq [3, 2, 1, -1, nil] }
+              its(:'index.to_a') { is_expected.to eq [:a, :a, 1, :c, 1] }
+            end
+          end
+        end
       end
 
       context "#index=" do
@@ -624,23 +1184,32 @@ describe Daru::Vector do
         end
       end
 
+      context "#reindex!" do
+        before do
+          @vector = Daru::Vector.new([1,2,3,4,5])
+          @index = Daru::Index.new([3,4,1,0,6])
+        end
+        it "intelligently reindexes" do
+          @vector.reindex!(@index)
+          expect(@vector).to eq(
+            Daru::Vector.new([4,5,2,1,nil], index: @index))
+        end
+      end
+
       context "#reindex" do
         before do
-          @vector = Daru::Vector.new([1,2,3,4,5], metadata: { cdc_type: 2 })
+          @vector = Daru::Vector.new([1,2,3,4,5])
           @index = Daru::Index.new([3,4,1,0,6])
         end
         it "intelligently reindexes" do
           expect(@vector.reindex(@index)).to eq(
             Daru::Vector.new([4,5,2,1,nil], index: @index))
         end
-        it "retains the original vector metadata" do
-          expect(@vector.reindex(@index).metadata).to eq({ cdc_type: 2 })
-        end
       end
 
       context "#dup" do
         before do
-          @dv = Daru::Vector.new [1,2], name: :yoda, metadata: { cdc_type: 2 }, index: [:happy, :lightsaber]
+          @dv = Daru::Vector.new [1,2], name: :yoda, index: [:happy, :lightsaber]
         end
 
         it "copies the original data" do
@@ -655,14 +1224,6 @@ describe Daru::Vector do
           expect(@dv.dup.name).to eq(:yoda)
         end
 
-        it "copies the original vector metadata" do
-          expect(@dv.dup.metadata).to eq({ cdc_type: 2 })
-        end
-
-        it "creates a new metadata object" do
-          expect(@dv.dup.metadata.object_id).not_to eq(@dv.metadata.object_id)
-        end
-
         it "copies the original index" do
           expect(@dv.dup.index).to eq(Daru::Index.new([:happy, :lightsaber]))
         end
@@ -786,70 +1347,39 @@ describe Daru::Vector do
     end
   end
 
-  context "#missing_values" do
-    before do
-      @common = Daru::Vector.new([5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99])
-    end
-
-    it "allows setting the value to be treated as missing" do
-      @common.missing_values = [10]
-      expect(@common.only_valid.to_a.sort).to eq(
-        [-99, -99, 1, 2, 3, 4, 5, 5, 5, 5, 5, 6, 6, 7, 8, 9]
-      )
-      expect(@common.to_a).to eq(
-        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99]
-      )
-
-      @common.missing_values = [-99]
-      expect(@common.only_valid.to_a.sort).to eq(
-        [1, 2, 3, 4, 5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10]
-      )
-      expect(@common.to_a).to eq(
-        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99]
-      )
-
-      @common.missing_values = []
-      expect(@common.only_valid.to_a.sort).to eq(
-        [-99, -99, 1, 2, 3, 4, 5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10]
-      )
-      expect(@common.to_a).to eq(
-        [5, 5, 5, 5, 5, 6, 6, 7, 8, 9, 10, 1, 2, 3, 4, nil, -99, -99]
-      )
+  context "#is_nil?" do
+    before(:each) do
+      @with_md    = Daru::Vector.new([1,2,nil,3,4,nil])
+      @without_md = Daru::Vector.new([1,2,3,4,5,6])
     end
 
-    it "responds to has_missing_data? with explicit missing_values" do
-      a = Daru::Vector.new [1,2,3,4,10]
-      a.missing_values = [10]
-
-      expect(a.has_missing_data?).to eq(true)
+    it "verifies missing data presence" do
+      expect(@with_md.is_nil?)   .to eq(Daru::Vector.new([false,false,true,false,false,true]))
+      expect(@without_md.is_nil?).to eq(Daru::Vector.new([false,false,false,false,false,false]))
     end
   end
 
-  context "#is_nil?" do
+  context "#not_nil?" do
     before(:each) do
       @with_md    = Daru::Vector.new([1,2,nil,3,4,nil])
       @without_md = Daru::Vector.new([1,2,3,4,5,6])
     end
 
     it "verifies missing data presence" do
-      expect(@with_md.is_nil?)   .to eq(Daru::Vector.new([false,false,true,false,false,true]))
-      expect(@without_md.is_nil?).to eq(Daru::Vector.new([false,false,false,false,false,false]))
+      expect(@with_md.not_nil?)   .to eq(Daru::Vector.new([true,true,false,true,true,false]))
+      expect(@without_md.not_nil?).to eq(Daru::Vector.new([true,true,true,true,true,true]))
     end
   end
 
   context "#clone_structure" do
     context Daru::Index do
       before do
-        @vec = Daru::Vector.new([1,2,3,4,5], metadata: { cdc_type: 2 }, index: [:a,:b,:c,:d,:e])
+        @vec = Daru::Vector.new([1,2,3,4,5], index: [:a,:b,:c,:d,:e])
       end
 
       it "clones a vector with its index and fills it with nils" do
         expect(@vec.clone_structure).to eq(Daru::Vector.new([nil,nil,nil,nil,nil], index: [:a,:b,:c,:d,:e]))
       end
-
-      it "retains the original vector metadata" do
-        expect(@vec.clone_structure.metadata).to eq({ cdc_type: 2 })
-      end
     end
 
     context Daru::MultiIndex do
@@ -857,25 +1387,187 @@ describe Daru::Vector do
     end
   end
 
-  context "#missing_positions" do
-    context Daru::Index do
-      before(:each) do
-        @with_md = Daru::Vector.new([1,2,nil,3,4,nil])
+  context '#reject_values'do
+    let(:dv) { Daru::Vector.new [1, nil, 3, :a, Float::NAN, nil, Float::NAN, 1],
+      index: 11..18 }
+    context 'reject only nils' do
+      subject { dv.reject_values nil }
+      
+      it { is_expected.to be_a Daru::Vector }
+      its(:to_a) { is_expected.to eq [1, 3, :a, Float::NAN, Float::NAN, 1] }
+      its(:'index.to_a') { is_expected.to eq [11, 13, 14, 15, 17, 18] }
+    end
+
+    context 'reject only float::NAN' do
+      subject { dv.reject_values Float::NAN }
+      
+      it { is_expected.to be_a Daru::Vector }
+      its(:to_a) { is_expected.to eq [1, nil, 3, :a, nil, 1] }
+      its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 16, 18] }
+    end
+
+    context 'reject both nil and float::NAN' do
+      subject { dv.reject_values nil, Float::NAN }
+      
+      it { is_expected.to be_a Daru::Vector }
+      its(:to_a) { is_expected.to eq [1, 3, :a, 1] }
+      its(:'index.to_a') { is_expected.to eq [11, 13, 14, 18] }
+    end
+    
+    context 'reject any other value' do
+      subject { dv.reject_values 1, 3 }
+      
+      it { is_expected.to be_a Daru::Vector }
+      its(:to_a) { is_expected.to eq [nil, :a, Float::NAN, nil, Float::NAN] }
+      its(:'index.to_a') { is_expected.to eq [12, 14, 15, 16, 17] }
+    end
+
+    context 'when resultant vector has only one value' do
+      subject { dv.reject_values 1, :a, nil, Float::NAN }
+      
+      it { is_expected.to be_a Daru::Vector }
+      its(:to_a) { is_expected.to eq [3] }
+      its(:'index.to_a') { is_expected.to eq [13] }
+    end
+    
+    context 'when resultant vector has no value' do
+      subject { dv.reject_values 1, 3, :a, nil, Float::NAN, 5 }
+      
+      it { is_expected.to be_a Daru::Vector }
+      its(:to_a) { is_expected.to eq [] }
+      its(:'index.to_a') { is_expected.to eq [] }
+    end
+    
+    context 'works for gsl' do
+      let(:dv) { Daru::Vector.new [1, 2, 3, Float::NAN], dtype: :gsl,
+        index: 11..14 }
+      subject { dv.reject_values Float::NAN }
+      
+      it { is_expected.to be_a Daru::Vector }
+      its(:dtype) { is_expected.to eq :gsl }
+      its(:to_a) { is_expected.to eq [1, 2, 3].map(&:to_f) }
+      its(:'index.to_a') { is_expected.to eq [11, 12, 13] }
+    end
+
+    context 'test caching' do
+      let(:dv) { Daru::Vector.new [nil]*8, index: 11..18}
+      before do
+        dv.reject_values nil
+        [1, nil, 3, :a, Float::NAN, nil, Float::NAN, 1].each_with_index do |v, pos|
+          dv.set_at [pos], v
+        end
+      end
+
+      context 'reject only nils' do
+        subject { dv.reject_values nil }
+        
+        it { is_expected.to be_a Daru::Vector }
+        its(:to_a) { is_expected.to eq [1, 3, :a, Float::NAN, Float::NAN, 1] }
+        its(:'index.to_a') { is_expected.to eq [11, 13, 14, 15, 17, 18] }
+      end
+  
+      context 'reject only float::NAN' do
+        subject { dv.reject_values Float::NAN }
+        
+        it { is_expected.to be_a Daru::Vector }
+        its(:to_a) { is_expected.to eq [1, nil, 3, :a, nil, 1] }
+        its(:'index.to_a') { is_expected.to eq [11, 12, 13, 14, 16, 18] }
       end
+  
+      context 'reject both nil and float::NAN' do
+        subject { dv.reject_values nil, Float::NAN }
+        
+        it { is_expected.to be_a Daru::Vector }
+        its(:to_a) { is_expected.to eq [1, 3, :a, 1] }
+        its(:'index.to_a') { is_expected.to eq [11, 13, 14, 18] }
+      end
+      
+      context 'reject any other value' do
+        subject { dv.reject_values 1, 3 }
+        
+        it { is_expected.to be_a Daru::Vector }
+        its(:to_a) { is_expected.to eq [nil, :a, Float::NAN, nil, Float::NAN] }
+        its(:'index.to_a') { is_expected.to eq [12, 14, 15, 16, 17] }
+      end
+    end
+  end
 
-      it "returns the indexes of nils" do
-        expect(@with_md.missing_positions).to eq([2,5])
+  context '#include_values?' do
+    context 'only nils' do
+      context 'true' do
+        let(:dv) { Daru::Vector.new [1, 2, 3, :a, 'Unknown', nil] }
+        it { expect(dv.include_values? nil).to eq true }
       end
 
-      it "updates after assingment" do
-        @with_md[3] = nil
-        expect(@with_md.missing_positions).to eq([2,3,5])
+      context 'false' do
+        let(:dv) { Daru::Vector.new [1, 2, 3, :a, 'Unknown'] }
+        it { expect(dv.include_values? nil).to eq false }
       end
     end
 
+    context 'only Float::NAN' do
+      context 'true' do
+        let(:dv) { Daru::Vector.new [1, nil, 2, 3, Float::NAN] }
+        it { expect(dv.include_values? Float::NAN).to eq true }
+      end
+
+      context 'false' do
+        let(:dv) { Daru::Vector.new [1, nil, 2, 3] }
+        it { expect(dv.include_values? Float::NAN).to eq false }
+      end
+    end
+
+    context 'both nil and Float::NAN' do
+      context 'true with only nil' do
+        let(:dv) { Daru::Vector.new [1, Float::NAN, 2, 3] }
+        it { expect(dv.include_values? nil, Float::NAN).to eq true }
+      end
+      
+      context 'true with only Float::NAN' do
+        let(:dv) { Daru::Vector.new [1, nil, 2, 3] }
+        it { expect(dv.include_values? nil, Float::NAN).to eq true }
+      end
+      
+      context 'false' do
+        let(:dv) { Daru::Vector.new [1, 2, 3] }
+        it { expect(dv.include_values? nil, Float::NAN).to eq false }
+      end
+    end
+    
+    context 'any other value' do
+      context 'true' do
+        let(:dv) { Daru::Vector.new [1, 2, 3, 4, nil] }
+        it { expect(dv.include_values? 1, 2, 3, 5).to eq true }
+      end
+      
+      context 'false' do
+        let(:dv) { Daru::Vector.new [1, 2, 3, 4, nil] }
+        it { expect(dv.include_values? 5, 6).to eq false }
+      end
+    end
+  end
+
+  context '#count_values' do
+    let(:dv) { Daru::Vector.new [1, 2, 3, 1, 2, nil, nil] }
+    it { expect(dv.count_values 1, 2).to eq 4 }
+    it { expect(dv.count_values nil).to eq 2 }
+    it { expect(dv.count_values 3, Float::NAN).to eq 1 }
+    it { expect(dv.count_values 4).to eq 0 }
+  end
+
+  context '#indexes' do
+    context Daru::Index do
+      let(:dv) { Daru::Vector.new [1, 2, 1, 2, 3, nil, nil, Float::NAN],
+        index: 11..18 }
+      
+      subject { dv.indexes 1, 2, nil, Float::NAN }
+      it { is_expected.to be_a Array }
+      it { is_expected.to eq [11, 12, 13, 14, 16, 17, 18] }
+    end
+    
     context Daru::MultiIndex do
-      it "returns indexes of nils" do
-        mi = Daru::MultiIndex.from_tuples([
+      let(:mi) do
+        Daru::MultiIndex.from_tuples([
           ['M', 2000],
           ['M', 2001],
           ['M', 2002],
@@ -884,14 +1576,47 @@ describe Daru::Vector do
           ['F', 2001],
           ['F', 2002],
           ['F', 2003]
-          ])
-        vector = Daru::Vector.new([nil,2,4,5,3,nil,2,nil], index: mi)
-        expect(vector.missing_positions).to eq([
-          ['M',2000],
-          ['F',2001],
-          ['F',2003]
         ])
       end
+      let(:dv) { Daru::Vector.new [1, 2, 1, 2, 3, nil, nil, Float::NAN],
+        index: mi }
+      
+      subject { dv.indexes 1, 2, Float::NAN }
+      it { is_expected.to be_a Array }
+      it { is_expected.to eq(
+        [
+          ['M', 2000],
+          ['M', 2001],
+          ['M', 2002],
+          ['M', 2003],
+          ['F', 2003]
+        ]) }
+    end
+  end
+  
+  context '#replace_values' do
+    subject do
+      Daru::Vector.new(
+        [1, 2, 1, 4, nil, Float::NAN, nil, Float::NAN],
+        index: 11..18
+      )
+    end
+
+    context 'replace nils and NaNs' do
+      before { subject.replace_values [nil, Float::NAN], 10 }
+      its(:to_a) { is_expected.to eq [1, 2, 1, 4, 10, 10, 10, 10] }
+    end
+    
+    context 'replace arbitrary values' do
+      before { subject.replace_values [1, 2], 10 }
+      its(:to_a) { is_expected.to eq(
+        [10, 10, 10, 4, nil, Float::NAN, nil, Float::NAN]) }
+    end
+    
+    context 'works for single value' do
+      before { subject.replace_values nil, 10 }
+      its(:to_a) { is_expected.to eq(
+        [1, 2, 1, 4, 10, Float::NAN, 10, Float::NAN]) }
     end
   end
 
@@ -967,25 +1692,38 @@ describe Daru::Vector do
     it "converts Daru::Vector to a vertical Ruby Matrix" do
       expect(@vector.to_matrix(:vertical)).to eq(Matrix.columns([[1,2,3,4,5,6]]))
     end
-  end
 
-  context "#only_valid" do
-    [:array, :gsl].each do |dtype|
-      describe dtype do
-        before do
-          @vector = Daru::Vector.new [1,2,3,4,5,3,5], metadata: { cdc_type: 2 },
-            index: [:a, :b, :c, :d, :e, :f, :g], dtype: dtype, missing_values: [3, 5]
-        end
+    it 'raises on wrong axis' do
+      expect { @vector.to_matrix(:strange) }.to raise_error(ArgumentError)
+    end
+  end
 
-        it "returns a Vector of only non-missing data" do
-          expect(@vector.only_valid).to eq(Daru::Vector.new([1,2,4],
-            index: [:a, :b, :d], dtype: dtype))
-        end
+  context '#to_nmatrix' do
+    let(:dv) { Daru::Vector.new [1, 2, 3, 4, 5] }
+    
+    context 'horizontal axis' do
+      subject { dv.to_nmatrix }
 
-        it "retains the original vector metadata" do
-          expect(@vector.only_valid.metadata).to eq({ cdc_type: 2 })
-        end
-      end
+      it { is_expected.to be_a NMatrix }
+      its(:shape) { is_expected.to eq [1, 5] }
+      its(:to_a) { is_expected.to eq [1, 2, 3, 4, 5] }
+    end
+    
+    context 'vertical axis' do
+      subject { dv.to_nmatrix :vertical }
+      
+      it { is_expected.to be_a NMatrix }
+      its(:shape) { is_expected.to eq [5, 1] }
+      its(:to_a) { is_expected.to eq [1, 2, 3, 4, 5].map { |i| [i] } }
+    end
+    
+    context 'invalid axis' do
+      it { expect { dv.to_nmatrix :hello }.to raise_error ArgumentError }
+    end
+    
+    context 'vector contain non-numeric' do
+      let(:dv) { Daru::Vector.new [1, 2, nil, 4] }
+      it { expect { dv.to_nmatrix }.to raise_error ArgumentError }
     end
   end
 
@@ -1054,17 +1792,10 @@ describe Daru::Vector do
     end
   end
 
-  context "#n_valid" do
-    it "returns number of non-missing positions" do
-      v = Daru::Vector.new [1,2,3,4,nil,nil,3,5]
-      expect(v.n_valid).to eq(6)
-    end
-  end
-
   context "#reset_index!" do
     it "resets any index to a numerical serialized index" do
       v = Daru::Vector.new([1,2,3,4,5,nil,nil,4,nil])
-      r = v.only_valid.reset_index!
+      r = v.reject_values(*Daru::MISSING_VALUES).reset_index!
       expect(r).to eq(Daru::Vector.new([1,2,3,4,5,4]))
       expect(r.index).to eq(Daru::Index.new([0,1,2,3,4,5]))
 
@@ -1087,6 +1818,10 @@ describe Daru::Vector do
       @v.rename "This is a vector"
       expect(@v.name).to eq("This is a vector")
     end
+
+    it "returns vector" do
+      expect(@v.rename 'hello').to be_a Daru::Vector
+    end
   end
 
   context "#any?" do
@@ -1117,16 +1852,6 @@ describe Daru::Vector do
     end
   end
 
-  context "#only_missing" do
-    it "returns a vector (with proper index) of all the elements marked 'missing'" do
-      v = Daru::Vector.new([1,2,3,4,5,6,4,5,5,4,4,nil,nil,nil])
-      v.missing_values = [nil, 5]
-
-      expect(v.only_missing).to eq(Daru::Vector.new([5,5,5,nil,nil,nil],
-        index: [4,7,8,11,12,13]))
-    end
-  end
-
   context "#detach_index" do
     it "creates a DataFrame with first Vector as index and second as values of the Vector" do
       v = Daru::Vector.new([1,2,3,4,5,6],
@@ -1141,7 +1866,7 @@ describe Daru::Vector do
   context "#lag" do
     before do
       @xiu = Daru::Vector.new([17.28, 17.45, 17.84, 17.74, 17.82, 17.85, 17.36, 17.3, 17.56, 17.49, 17.46, 17.4, 17.03, 17.01,
-        16.86, 16.86, 16.56, 16.36, 16.66, 16.77], metadata: { cdc_type: 2 })
+        16.86, 16.86, 16.56, 16.36, 16.66, 16.77])
     end
 
     it "lags the vector by specified amount" do
@@ -1156,16 +1881,58 @@ describe Daru::Vector do
       expect(lag2[lag2.size - 1]).to be_within(0.001).of(16.36)
       expect(lag2[lag2.size - 2]).to be_within(0.001).of(16.56)
     end
+  end
+
+  context '#method_missing' do
+    context 'getting' do
+      subject(:vector) { Daru::Vector.new [1,2,3], index: [:a, :b, :c] }
 
-    it "retains the original vector metadata" do
-      expect(@xiu.lag(1).metadata).to eq({ cdc_type: 2 })
+      it 'returns value for existing index' do
+        expect(vector.a).to eq 1
+      end
+
+      it 'raises on getting non-existent index' do
+        expect { vector.d }.to raise_error NoMethodError
+      end
+
+      it 'sets existing index' do
+        vector.a = 5
+        expect(vector[:a]).to eq 5
+      end
+
+      it 'raises on non-existent index setting' do
+        # FIXME: inconsistency between IndexError here and NoMethodError on getting - zverok
+        expect { vector.d = 5 }.to raise_error IndexError
+      end
     end
   end
 
-  context "#metadata" do
-    it "defaults to an empty hash for metadata" do
-      dv = Daru::Vector.new [1,2,3,4,5]
-      expect(dv.metadata).to eq({})
+  context '#db_type' do
+    it 'is DATE for vector with any date in it' do
+      # FIXME: is it sane?.. - zverok
+      expect(Daru::Vector.new(['2016-03-01', 'foo', 4]).db_type).to eq 'DATE'
+    end
+
+    it 'is INTEGER for digits-only values' do
+      expect(Daru::Vector.new(['123', 456, 789]).db_type).to eq 'INTEGER'
+    end
+
+    it 'is DOUBLE for digits-and-point values' do
+      expect(Daru::Vector.new(['123.4', 456, 789e-10]).db_type).to eq 'DOUBLE'
+    end
+
+    it 'is VARCHAR for everyting else' do
+      expect(Daru::Vector.new(['123 and stuff', 456, 789e-10]).db_type).to eq 'VARCHAR (255)'
+    end
+  end
+
+  context 'on wrong dtypes' do
+    it 'should not accept mdarray' do
+      expect { Daru::Vector.new([], dtype: :mdarray) }.to raise_error(NotImplementedError)
+    end
+
+    it 'should not accept anything else' do
+      expect { Daru::Vector.new([], dtype: :kittens) }.to raise_error(ArgumentError)
     end
   end