daru 0.0.4 → 0.0.5

data/spec/multi_index_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper.rb'
+
+describe Daru::MultiIndex do
+  before(:each) do
+    @index_tuples = [
+      [:a,:one,:bar],
+      [:a,:one,:baz],
+      [:a,:two,:bar],
+      [:a,:two,:baz],
+      [:b,:one,:bar],
+      [:b,:two,:bar],
+      [:b,:two,:baz],
+      [:b,:one,:foo],
+      [:c,:one,:bar],
+      [:c,:one,:baz],
+      [:c,:two,:foo],
+      [:c,:two,:bar]
+    ]
+    @multi_mi = Daru::MultiIndex.new(@index_tuples)
+  end
+
+  context "#initialize" do
+    it "creates 2 layer MultiIndex from tuples" do
+      tuples = [[:a, :one], [:a, :two], [:b, :one], [:b, :two], [:c, :one], [:c, :two]]
+      mi = Daru::MultiIndex.new(tuples)
+      expect(mi.relation_hash).to eq({
+        :a => {
+          :one => 0, 
+          :two => 1
+        },
+        :b => {
+          :one => 2,
+          :two => 3
+        },
+        :c => {
+          :one => 4,
+          :two => 5
+        }
+      })
+    end
+
+    it "creates a triple layer MultiIndex from tuples" do
+      expect(@multi_mi.relation_hash).to eq({
+        :a => {
+          :one => {
+            :bar => 0,
+            :baz => 1
+            },
+          :two => {
+            :bar => 2,
+            :baz => 3
+          }
+        },
+        :b => {
+          :one => {
+            :bar => 4,
+            :foo => 7
+          },
+          :two => {
+            :bar => 5,
+            :baz => 6
+          }
+        },
+        :c => {
+          :one => {
+            :bar => 8,
+            :baz => 9
+          },
+          :two => {
+            :foo => 10,
+            :bar => 11,
+          }
+        }
+      })
+    end
+
+    it "accepts array index values externally" do
+      mi = Daru::MultiIndex.new([
+        [:a,:one,:bar],
+        [:a,:one,:baz],
+        [:a,:two,:bar],
+        [:a,:two,:baz],
+        [:b,:one,:bar]
+      ], [6,3,1,2,9])
+
+      expect(mi[:a,:two,:baz]).to eq(2)
+    end
+  end 
+
+  context "#size" do
+    it "returns size of MultiIndex" do
+      expect(@multi_mi.size).to eq(12)
+    end
+  end
+
+  context "#[]" do
+    it "returns the row number when specifying the complete tuple" do
+      expect(@multi_mi[:a, :one, :baz]).to eq(1)
+    end
+
+    it "returns a MultiIndex when specifying incomplete tuple" do
+      expect(@multi_mi[:b]).to eq(Daru::MultiIndex.new([
+          [:one,:bar],
+          [:two,:bar],
+          [:two,:baz],
+          [:one,:foo]
+        ], [4,5,6,7])
+      )
+
+      expect(@multi_mi[:b, :one]).to eq(Daru::MultiIndex.new([
+          [:bar],
+          [:foo]
+        ], [4,7])
+      )
+      # TODO: Return Daru::Index if a single layer of indexes is present.
+    end
+
+    it "returns a MultiIndex when specifying as an integer index" do
+      expect(@multi_mi[1]).to eq(Daru::MultiIndex.new([
+          [:one,:bar],
+          [:two,:bar],
+          [:two,:baz],
+          [:one,:foo]
+        ],[4,5,6,7])
+      )
+    end
+
+    it "supports numeric Ranges" do
+      expect(@multi_mi[0..1]).to eq(Daru::MultiIndex.new([        
+        [:a,:one,:bar],
+        [:a,:one,:baz],
+        [:a,:two,:bar],
+        [:a,:two,:baz],
+        [:b,:one,:bar],
+        [:b,:two,:bar],
+        [:b,:two,:baz],
+        [:b,:one,:foo]
+      ]))
+    end
+  end
+
+  context "#include?" do
+    it "checks if a completely specified tuple exists" do
+      expect(@multi_mi.include?([:a,:one,:bar])).to eq(true)
+    end
+
+    it "checks if a top layer incomplete tuple exists" do
+      expect(@multi_mi.include?([:a])).to eq(true)
+    end
+
+    it "checks if a middle layer incomplete tuple exists" do
+      expect(@multi_mi.include?([:a, :one])).to eq(true)
+    end
+
+    it "checks for non-existence of a tuple" do
+      expect(@multi_mi.include?([:boo])).to eq(false)
+    end
+  end
+
+  context "#key" do
+    it "returns the tuple of the specified number" do
+      expect(@multi_mi.key(3)).to eq([:a,:two,:baz])
+    end
+
+    it "returns nil for non-existent pointer number" do
+      expect(@multi_mi.key(100)).to eq(nil)
+    end
+  end
+
+  context "#to_a" do
+    it "returns tuples as an Array" do
+      expect(@multi_mi.to_a).to eq(@index_tuples)
+    end
+  end
+
+  context "#dup" do
+    it "completely duplicates the object" do
+      duplicate = @multi_mi.dup
+      
+      expect(duplicate)          .to eq(@multi_mi)
+      expect(duplicate.object_id).to_not eq(@multi_mi.object_id)
+    end
+  end
+
+  context "#==" do
+    it "returns false for unequal MultiIndex comparisons" do
+      mi1 = Daru::MultiIndex.new([
+        [:a, :one, :bar],
+        [:a, :two, :baz],
+        [:b, :one, :foo],
+        [:b, :two, :bar]
+        ])
+      mi2 = Daru::MultiIndex.new([
+        [:a, :two, :bar],
+        [:b, :one, :foo],
+        [:a, :one, :baz],
+        [:b, :two, :baz]
+        ])
+
+      expect(mi1 == mi2).to eq(false)
+    end
+  end
+
+  context "#values" do
+    it "returns an array of indices in order" do
+      mi = Daru::MultiIndex.new([
+        [:a, :one, :bar],
+        [:a, :two, :baz],
+        [:b, :one, :foo],
+        [:b, :two, :bar]
+        ], [3,5,1,6])
+
+      expect(mi.values).to eq([3,5,1,6])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'rspec'
 require 'awesome_print'
+require 'matrix'
 
 def mri?
   RUBY_ENGINE == 'ruby'

data/spec/vector_spec.rb

@@ -1,9 +1,22 @@
 require 'spec_helper.rb'
 
 describe Daru::Vector do
-  [Array, NMatrix].each do |dtype|
+  ALL_DTYPES = [:array, :nmatrix]
+
+  ALL_DTYPES.each do |dtype|
     describe dtype do
       context "#initialize" do
+        before do
+          @tuples = [
+            [:a, :one, :foo], 
+            [:a, :two, :bar], 
+            [:b, :one, :bar], 
+            [:b, :two, :baz]
+          ]
+
+          @multi_index = Daru::MultiIndex.new(@tuples)
+        end
+
         it "initializes from an Array" do
           dv = Daru::Vector.new [1,2,3,4,5], name: :ravan, 
             index: [:ek, :don, :teen, :char, :pach], dtype: dtype
@@ -14,13 +27,19 @@ describe Daru::Vector do
 
         it "accepts Index object" do
           idx = Daru::Index.new [:yoda, :anakin, :obi, :padme, :r2d2]
-
           dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, index: idx, dtype: dtype
 
           expect(dv.name) .to eq(:yoga)
           expect(dv.index).to eq(idx)
         end
 
+        it "accepts a MultiIndex object" do
+          dv = Daru::Vector.new [1,2,3,4], name: :mi, index: @multi_index, dtype: dtype
+
+          expect(dv.name).to eq(:mi)
+          expect(dv.index).to eq(@multi_index)
+        end
+
         it "raises error for improper Index" do
           expect {
             dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, index: [:i, :j, :k]
@@ -32,6 +51,12 @@ describe Daru::Vector do
           }.to raise_error
         end
 
+        it "raises error for improper MultiIndex" do
+          expect {
+            dv = Daru::Vector.new [1,2,3,4,5], name: :mi, index: @multi_index
+          }.to raise_error
+        end
+
         it "initializes without specifying an index" do
           dv = Daru::Vector.new [1,2,3,4,5], name: :vishnu, dtype: dtype
 
@@ -39,48 +64,184 @@ describe Daru::Vector do
         end
 
         it "inserts nils for extra indices" do
-          dv = Daru::Vector.new [1,2,3], name: :yoga, index: [0,1,2,3,4], dtype: Array
+          dv = Daru::Vector.new [1,2,3], name: :yoga, index: [0,1,2,3,4], dtype: :array
 
           expect(dv).to eq([1,2,3,nil,nil].dv(:yoga,nil, Array))
         end
-      end
-
-      context "#[]" do
-        before :each do
-          @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, 
-            index: [:yoda, :anakin, :obi, :padme, :r2d2], dtype: dtype
-        end
 
-        it "returns an element after passing an index" do
-          expect(@dv[:yoda]).to eq(1)
+        it "inserts nils for extra indices (MultiIndex)" do
+          dv = Daru::Vector.new [1,2], name: :mi, index: @multi_index, dtype: :array
+          expect(dv).to eq(Daru::Vector.new([1,2,nil,nil], name: :mi, index: @multi_index, dtype: :array))
         end
+      end
 
-        it "returns an element after passing a numeric index" , :focus => true do
-          expect(@dv[0]).to eq(1)
+      context "#[]" do
+        context Daru::Index do
+          before :each do
+            @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, 
+              index: [:yoda, :anakin, :obi, :padme, :r2d2], dtype: dtype
+          end
+
+          it "returns an element after passing an index" do
+            expect(@dv[:yoda]).to eq(1)
+          end
+
+          it "returns an element after passing a numeric index" do
+            expect(@dv[0]).to eq(1)
+          end
+
+          it "returns a vector with given indices for multiple indices" do
+            expect(@dv[:yoda, :anakin]).to eq(Daru::Vector.new([1,2], name: :yoda, 
+              index: [:yoda, :anakin], dtype: dtype))
+          end
+
+          it "returns a vector with given indices for multiple numeric indices" do
+            expect(@dv[0,1]).to eq(Daru::Vector.new([1,2], name: :yoda, 
+              index: [:yoda, :anakin], dtype: dtype))
+          end
+
+          it "returns a vector when specified symbol Range" do
+            expect(@dv[:yoda..:anakin]).to eq(Daru::Vector.new([1,2], 
+              index: [:yoda, :anakin], name: :yoga, dtype: dtype))
+          end
+
+          it "returns a vector when specified numeric Range" do
+            expect(@dv[3..4]).to eq(Daru::Vector.new([4,5], name: :yoga, 
+              index: [:padme, :r2d2], name: :yoga, dtype: dtype))
+          end
         end
 
-        it "returns a vector with given indices for multiple indices" do
-          expect(@dv[:yoda, :anakin]).to eq(Daru::Vector.new([1,2], name: :yoda, 
-            index: [:yoda, :anakin], dtype: dtype))
+        context Daru::MultiIndex do
+          before do
+            @tuples = [
+              [:a,:one,:bar],
+              [:a,:one,:baz],
+              [:a,:two,:bar],
+              [:a,:two,:baz],
+              [:b,:one,:bar],
+              [:b,:two,:bar],
+              [:b,:two,:baz],
+              [:b,:one,:foo],
+              [:c,:one,:bar],
+              [:c,:one,:baz],
+              [:c,:two,:foo],
+              [:c,:two,:bar]
+            ]
+            @multi_index = Daru::MultiIndex.new(@tuples)
+            @vector = Daru::Vector.new Array.new(12) { |i| i }, index: @multi_index, 
+              dtype: dtype, name: :mi_vector
+          end
+
+          it "returns a single element when passed a row number" do
+            expect(@vector[1]).to eq(1)
+          end
+
+          it "returns a single element when passed the full tuple" do
+            expect(@vector[:a, :one, :baz]).to eq(1)
+          end
+
+          it "returns sub vector when passed first layer of tuple" do
+            mi = Daru::MultiIndex.new([
+              [:one,:bar],
+              [:one,:baz],
+              [:two,:bar],
+              [:two,:baz]])
+            expect(@vector[:a]).to eq(Daru::Vector.new([0,1,2,3], index: mi, 
+              dtype: dtype, name: :sub_vector))
+          end
+
+          it "returns sub vector when passed first and second layer of tuple" do
+            mi = Daru::MultiIndex.new([
+              [:foo],
+              [:bar]])
+            expect(@vector[:c,:two]).to eq(Daru::Vector.new([10,11], index: mi,
+              dtype: dtype, name: :sub_sub_vector))
+          end
+
+          it "returns a vector with corresponding MultiIndex when specified numeric Range" do
+            mi = Daru::MultiIndex.new([
+              [:a,:two,:baz],
+              [:b,:one,:bar],
+              [:b,:two,:bar],
+              [:b,:two,:baz],
+              [:b,:one,:foo],
+              [:c,:one,:bar],
+              [:c,:one,:baz]
+            ])
+            expect(@vector[3..9]).to eq(Daru::Vector.new([3,4,5,6,7,8,9], index: mi,
+              dtype: dtype, name: :slice))
+          end
         end
       end
 
       context "#[]=" do
-        before :each do
-          @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, 
-            index: [:yoda, :anakin, :obi, :padme, :r2d2], dtype: dtype
+        context Daru::Index do
+          before :each do
+            @dv = Daru::Vector.new [1,2,3,4,5], name: :yoga, 
+              index: [:yoda, :anakin, :obi, :padme, :r2d2], dtype: dtype
+          end
+
+          it "assigns at the specified index" do
+            @dv[:yoda] = 666
+            expect(@dv[:yoda]).to eq(666)
+          end
+
+          it "assigns at the specified Integer index" do
+            @dv[0] = 666
+            expect(@dv[:yoda]).to eq(666)
+          end
+
+          it "sets dtype to Array if a nil is assigned" do
+            @dv[0] = nil
+            expect(@dv.dtype).to eq(:array)
+          end
         end
 
-        it "assigns at the specified index" do
-          @dv[:yoda] = 666
-
-          expect(@dv[:yoda]).to eq(666)
-        end
-
-        it "assigns at the specified Integer index" do
-          @dv[0] = 666
-
-          expect(@dv[:yoda]).to eq(666)
+        context Daru::MultiIndex do
+          before :each do
+            @tuples = [
+              [:a,:one,:bar],
+              [:a,:one,:baz],
+              [:a,:two,:bar],
+              [:a,:two,:baz],
+              [:b,:one,:bar],
+              [:b,:two,:bar],
+              [:b,:two,:baz],
+              [:b,:one,:foo],
+              [:c,:one,:bar],
+              [:c,:one,:baz],
+              [:c,:two,:foo],
+              [:c,:two,:bar]
+            ]
+            @multi_index = Daru::MultiIndex.new(@tuples)
+            @vector = Daru::Vector.new Array.new(12) { |i| i }, index: @multi_index, 
+              dtype: dtype, name: :mi_vector
+          end
+
+          it "assigns all lower layer indices when specified a first layer index" do
+            @vector[:b] = 69
+            expect(@vector).to eq(Daru::Vector.new([0,1,2,3,69,69,69,69,8,9,10,11],
+              index: @multi_index, name: :top_layer_assignment, dtype: dtype
+              ))
+          end
+
+          it "assigns all lower indices when specified first and second layer index" do
+            @vector[:b, :one] = 69
+            expect(@vector).to eq(Daru::Vector.new([0,1,2,3,69,5,6,69,8,9,10,11],
+              index: @multi_index, name: :second_layer_assignment, dtype: dtype))
+          end
+
+          it "assigns just the precise value when specified complete tuple" do
+            @vector[:b, :one, :foo] = 69
+            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 "assigns correctly when numeric index" do
+            @vector[7] = 69
+            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
         end
       end
 
@@ -116,57 +277,344 @@ describe Daru::Vector do
       end
 
       context "#delete" do
-        it "deletes specified value in the vector" do
-          dv = Daru::Vector.new [1,2,3,4,5], name: :a, dtype: dtype
+        context Daru::Index do
+          it "deletes specified value in the vector" do
+            dv = Daru::Vector.new [1,2,3,4,5], name: :a, dtype: dtype
 
-          dv.delete 3
+            dv.delete 3
+            expect(dv).to eq(Daru::Vector.new [1,2,4,5], name: :a)
+          end
+        end
 
-          expect(dv).to eq(Daru::Vector.new [1,2,4,5], name: :a)
+        context Daru::MultiIndex do
+          pending
         end
       end
 
       context "#delete_at" do
-        before :each do
-          @dv = Daru::Vector.new [1,2,3,4,5], name: :a, 
-            index: [:one, :two, :three, :four, :five], dtype: dtype
-        end
+        context Daru::Index do
+          before :each do
+            @dv = Daru::Vector.new [1,2,3,4,5], name: :a, 
+              index: [:one, :two, :three, :four, :five], dtype: dtype
+          end
 
-        it "deletes element of specified index" do
-          @dv.delete_at :one
+          it "deletes element of specified index" do
+            @dv.delete_at :one
 
-          expect(@dv).to eq(Daru::Vector.new [2,3,4,5], name: :a, 
-            index: [:two, :three, :four, :five]), dtype: dtype
-        end
+            expect(@dv).to eq(Daru::Vector.new [2,3,4,5], name: :a, 
+              index: [:two, :three, :four, :five]), dtype: dtype
+          end
+
+          it "deletes element of specified integer index" do
+            @dv.delete_at 2
 
-        it "deletes element of specified integer index" do
-          @dv.delete_at 2
+            expect(@dv).to eq(Daru::Vector.new [1,2,4,5], name: :a, 
+              index: [:one, :two, :four, :five]), dtype: dtype
+          end
+        end
 
-          expect(@dv).to eq(Daru::Vector.new [1,2,4,5], name: :a, 
-            index: [:one, :two, :four, :five]), dtype: dtype
+        context Daru::MultiIndex do
+          pending "Possibly next release"
         end
       end
 
       context "#index_of" do
-        it "returns index of specified value" do
-          dv = Daru::Vector.new [1,2,3,4,5], name: :a, 
-            index: [:one, :two, :three, :four, :five], dtype: dtype
+        context Daru::Index do
+          it "returns index of specified value" do
+            dv = Daru::Vector.new [1,2,3,4,5], name: :a, 
+              index: [:one, :two, :three, :four, :five], dtype: dtype
 
-          expect(dv.index_of(1)).to eq(:one)
+            expect(dv.index_of(1)).to eq(:one)
+          end
+        end
+
+        context Daru::MultiIndex do
+          it "returns tuple of specified value" do
+            mi = Daru::MultiIndex.new([
+              [:a,:two,:bar],
+              [:a,:two,:baz],
+              [:b,:one,:bar],
+              [:b,:two,:bar]
+            ])
+            vector = Daru::Vector.new([1,2,3,4], index: mi, dtype: dtype)
+            expect(vector.index_of(3)).to eq([:b,:one,:bar])
+          end
         end
       end
 
       context "#to_hash" do
-        it "returns the vector as a hash" do
-          dv = Daru::Vector.new [1,2,3,4,5], name: :a, 
-            index: [:one, :two, :three, :four, :five], dtype: dtype
+        context Daru::Index do
+          it "returns the vector as a hash" do
+            dv = Daru::Vector.new [1,2,3,4,5], name: :a, 
+              index: [:one, :two, :three, :four, :five], dtype: dtype
+
+            expect(dv.to_hash).to eq({one: 1, two: 2, three: 3, four: 4, five: 5})
+          end
+        end
 
-          expect(dv.to_hash).to eq({one: 1, two: 2, three: 3, four: 4, five: 5})
+        context Daru::MultiIndex do
+          pending
+          # it "returns vector as a Hash" do
+          #   pending
+          #   mi = Daru::MultiIndex.new([
+          #     [:a,:two,:bar],
+          #     [:a,:two,:baz],
+          #     [:b,:one,:bar],
+          #     [:b,:two,:bar]
+          #   ])
+          #   vector = Daru::Vector.new([1,2,3,4], index: mi, dtype: dtype)
+          #   expect(vector.to_hash).to eq({
+          #     [:a,:two,:bar] => 1,
+          #     [:a,:two,:baz] => 2,
+          #     [:b,:one,:bar] => 3,
+          #     [:b,:two,:bar] => 4
+          #   })
+          # end
         end
       end
 
       context "#uniq" do
-        # TODO
+        it "keeps only unique values" do
+          # TODO: fill this in
+        end
+      end
+
+      context "#cast" do
+        ALL_DTYPES.each do |new_dtype|
+          it "casts from #{dtype} to #{new_dtype}" do
+            v = Daru::Vector.new [1,2,3,4], dtype: dtype
+            v.cast(dtype: new_dtype)
+            expect(v.dtype).to eq(new_dtype)
+          end
+        end
       end
+
+      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]
+          end
+
+          it "sorts the vector with defaults and returns a new vector, preserving indexing" do
+            expect(@dv.sort).to eq(Daru::Vector.new([1,2,15,33,332], name: :dv, index: [:e, :b, :c, :a, :d]))
+          end
+
+          it "sorts the vector in descending order" do
+            expect(@dv.sort(ascending: false)).to eq(Daru::Vector.new([332,33,15,2,1], name: :dv, index: [:d, :a, :c, :b, :e]))
+          end
+
+          it "accepts a block" do
+            str_dv = Daru::Vector.new ["My Jazz Guitar", "Jazz", "My", "Guitar"]
+
+            sorted = str_dv.sort { |a,b| a.length <=> b.length }
+            expect(sorted).to eq(Daru::Vector.new(["My", "Jazz", "Guitar", "My Jazz Guitar"], index: [2,1,3,0]))
+          end
+
+          it "places nils near the end of the vector" do
+            pending
+            with_nils = Daru::Vector.new [22,4,nil,111,nil,2]
+
+            expect(with_nils.sort).to eq(Daru::Vector.new([2,4,22,111,nil,nil], index: [5,1,0,3,2,4]))
+          end if dtype == :array
+        end
+
+        context Daru::MultiIndex do
+          before do
+            mi = Daru::MultiIndex.new([
+              [:a, :one,   :foo], 
+              [:a, :two,   :bar], 
+              [:b, :one,   :bar], 
+              [:b, :two,   :baz],
+              [:b, :three, :bar]
+              ])
+            @vector = Daru::Vector.new([44,22,111,0,-56], index: mi, name: :unsorted,
+              dtype: dtype)
+          end
+
+          it "sorts vector" do
+            mi_asc = Daru::MultiIndex.new([
+              [:b, :three, :bar],
+              [:b, :two,   :baz],
+              [:a, :two,   :bar],
+              [:a, :one,   :foo],
+              [:b, :one,   :bar]
+            ])
+            expect(@vector.sort).to eq(Daru::Vector.new([-56,0,22,44,111], index: mi_asc,
+              name: :ascending, dtype: dtype))
+          end
+
+          it "sorts in descending" do
+            mi_dsc = Daru::MultiIndex.new([
+              [:b, :one, :bar], 
+              [:a, :one, :foo], 
+              [:a, :two, :bar], 
+              [:b, :two, :baz], 
+              [:b, :three, :bar]
+            ])
+            expect(@vector.sort(ascending: false)).to eq(Daru::Vector.new(
+              [111,44,22,0,-56], index: mi_dsc, name: :descending, dtype: dtype))
+          end
+
+          it "sorts using the supplied block" do
+            mi_abs = Daru::MultiIndex.new([
+              [:b, :two,   :baz],
+              [:a, :two,   :bar],
+              [:a, :one,   :foo],
+              [:b, :three, :bar],
+              [:b, :one,   :bar]
+            ])
+            expect(@vector.sort { |a,b| a.abs <=> b.abs }).to eq(Daru::Vector.new(
+              [0,22,44,-56,111], index: mi_abs, name: :sort_abs, dtype: dtype))
+          end
+        end
+      end
+
+      context "#reindex" do
+        context Daru::Index do
+          before do 
+            @dv = Daru::Vector.new [1,2,3,4,5], name: :dv, index: [:a, :b, :c, :d, :e]
+          end
+
+          it "recreates index with sequential numbers" do
+            a  = @dv.reindex(:seq)
+
+            expect(a).to eq(Daru::Vector.new([1,2,3,4,5], name: :dv, index: [0,1,2,3,4]))
+            expect(a).to_not eq(@dv)
+          end
+
+          it "accepts a new non-numeric index" do
+            a = @dv.reindex([:hello, :my, :name, :is, :ted])
+
+            expect(a).to eq(Daru::Vector.new([1,2,3,4,5], name: :dv, index: [:hello, :my, :name, :is, :ted]))
+            expect(a).to_not eq(@dv)
+          end
+        end
+
+        context Daru::MultiIndex do
+          pending
+        end
+      end
+    end
+  end # checking with ALL_DTYPES
+
+  # works with arrays only
+  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 "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 "#clone_structure" do
+    context Daru::Index do
+      it "clones a vector with its index and fills it with nils" do
+        vec = Daru::Vector.new([1,2,3,4,5], index: [:a,:b,:c,:d,:e])
+        expect(vec.clone_structure).to eq(Daru::Vector.new([nil,nil,nil,nil,nil], index: [:a,:b,:c,:d,:e]))
+      end
+    end
+    
+    context Daru::MultiIndex do
+      pending
+    end
+  end
+
+  context "#nil_positions" do
+    context Daru::Index do
+      before(:each) do
+        @with_md = Daru::Vector.new([1,2,nil,3,4,nil])
+      end
+
+      it "returns the indexes of nils" do
+        expect(@with_md.nil_positions).to eq([2,5])
+      end
+
+      it "updates after assingment" do
+        @with_md[3] = nil
+        expect(@with_md.nil_positions).to eq([2,3,5])
+      end
+    end
+
+    context Daru::MultiIndex do
+      pending
+    end
+  end
+
+  context "#replace_nils" do
+    it "replaces all nils with the specified value" do
+      vec = Daru::Vector.new([1,2,3,nil,nil,4])
+      expect(vec.replace_nils(2)).to eq(Daru::Vector.new([1,2,3,2,2,4]))
+    end
+
+    it "replaces all nils with the specified value (bang)" do
+      vec = Daru::Vector.new([1,2,3,nil,nil,4]).replace_nils!(2)
+      expect(vec).to eq(Daru::Vector.new([1,2,3,2,2,4]))
+    end
+  end
+
+  context "#type" do
+    before(:each) do
+      @numeric = Daru::Vector.new([1,2,3,4,5])
+      @multi = Daru::Vector.new([1,2,3,'sameer','d'])
+      @with_nils = Daru::Vector.new([1,2,3,4,nil])
+    end
+
+    it "checks numeric data correctly" do
+      expect(@numeric.type).to eq(:numeric)
+    end
+
+    it "checks for multiple types of data" do
+      expect(@multi.type).to eq(:object)
+    end
+
+    it "tells NMatrix data type in case of NMatrix wrapper" do
+      nm = Daru::Vector.new([1,2,3,4,5], dtype: :nmatrix)
+      expect(nm.type).to eq(:int32)
+    end
+
+    it "changes type to object as per assignment" do
+      expect(@numeric.type).to eq(:numeric)
+      @numeric[2] = 'my string'
+      expect(@numeric.type).to eq(:object)
+    end
+
+    it "changes type to numeric as per assignment" do
+      expect(@multi.type).to eq(:object)
+      @multi[3] = 45
+      @multi[4] = 54
+      expect(@multi.type).to eq(:numeric) 
+    end
+
+    it "reports numeric if nils with number data" do
+      expect(@with_nils.type).to eq(:numeric)
+    end
+
+    it "stays numeric when nil is reassigned to a number" do
+      @with_nils[4] = 66
+      expect(@with_nils.type).to eq(:numeric)
+    end
+
+    it "changes to :object when nil is reassigned to anything but a number" do
+      @with_nils[4] = 'string'
+      expect(@with_nils.type).to eq(:object)
+    end
+  end
+
+  context "#to_matrix" do
+    before do
+      @vector = Daru::Vector.new [1,2,3,4,5,6]
+    end
+
+    it "converts Daru::Vector to a horizontal Ruby Matrix" do
+      expect(@vector.to_matrix).to eq(Matrix[[1,2,3,4,5,6]])
+    end
+
+    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
-end if mri?
+end if mri?