daru 0.1.0 → 0.1.1

data/lib/daru/version.rb

@@ -1,3 +1,3 @@
 module Daru
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/core/group_by_spec.rb

@@ -13,23 +13,23 @@ describe Daru::Core::GroupBy do
     @dl_group = @df.group_by([:a, :b])
     @tl_group = @df.group_by([:a,:b,:c])
 
-    @sl_index = Daru::Index.new([:bar, :foo])
-    @dl_multi_index = Daru::MultiIndex.new([
-      [:bar, :one],
-      [:bar, :three],
-      [:bar, :two],
-      [:foo, :one],
-      [:foo, :three],
-      [:foo, :two]
+    @sl_index = Daru::Index.new(['bar', 'foo'])
+    @dl_multi_index = Daru::MultiIndex.from_tuples([
+      ['bar', 'one'],
+      ['bar', 'three'],
+      ['bar', 'two'],
+      ['foo', 'one'],
+      ['foo', 'three'],
+      ['foo', 'two']
     ])
-    @tl_multi_index = Daru::MultiIndex.new([
-      [:bar, :one  , 2],
-      [:bar, :three, 1],
-      [:bar, :two  , 6],
-      [:foo, :one  , 1],
-      [:foo, :one  , 3],
-      [:foo, :three, 8],
-      [:foo, :two  , 3]
+    @tl_multi_index = Daru::MultiIndex.from_tuples([
+      ['bar', 'one'  , 2],
+      ['bar', 'three', 1],
+      ['bar', 'two'  , 6],
+      ['foo', 'one'  , 1],
+      ['foo', 'one'  , 3],
+      ['foo', 'three', 8],
+      ['foo', 'two'  , 3]
     ])
   end
 

data/spec/core/merge_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Daru::DataFrame do
+  context "#join" do
+    before do
+      @left = Daru::DataFrame.new({
+        :id   => [1,2,3,4],
+        :name => ['Pirate', 'Monkey', 'Ninja', 'Spaghetti']
+      })
+      @right = Daru::DataFrame.new({
+        :id => [1,2,3,4],
+        :name => ['Rutabaga', 'Pirate', 'Darth Vader', 'Ninja']
+      })
+    end
+
+    it "performs an inner join of two dataframes" do
+      answer = Daru::DataFrame.new({
+        :id_1   => [1,3],
+        :name => ['Pirate', 'Ninja'],
+        :id_2   => [2,4]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :inner, on: [:name])).to eq(answer)
+    end
+
+    it "performs a full outer join" do
+      answer = Daru::DataFrame.new({
+        :id_1 => [1,2,3,4,nil,nil],
+        :name => ['Pirate', 'Monkey', 'Ninja', 'Spaghetti','Rutabaga', 'Darth Vader'],
+        :id_2 => [2,nil,4,nil,1,3]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
+    end
+
+    it "performs a left outer join", focus: true do
+      answer = Daru::DataFrame.new({
+        :id_1 => [1,2,3,4],
+        :name => ['Pirate', 'Monkey', 'Ninja', 'Spaghetti'],
+        :id_2 => [2,nil,4,nil]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :left, on: [:name])).to eq(answer)
+    end
+
+    it "performs a right outer join" do
+      answer = Daru::DataFrame.new({
+        :id_1 => [nil,1,nil,3],
+        :name => ['Rutabaga','Pirate', 'Darth Vader', 'Ninja'],
+        :id_2 => [1,2,3,4]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :right, on: [:name])).to eq(answer)
+    end
+  end
+end

data/spec/core/query_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe Daru::Core::Query::BoolArray do
+  before do
+    @klass = Daru::Core::Query::BoolArray 
+    @left = @klass.new([true, true, true, false, false, true])
+    @right = @klass.new([false, false, false, false, true, false])
+  end
+
+  context "#&" do
+    it "computes and logic of each element in the array" do
+      expect(@left & @right).to eq(
+        @klass.new([false, false, false, false, false, false]))
+    end
+  end
+
+  context "#|" do
+    it "computes or logic of each element in arrays" do
+      expect(@left | @right).to eq(
+        @klass.new([true, true, true, false, true, true]))
+    end
+  end
+
+  context "#!" do
+    it "computes not logic of each element" do
+      expect(!@left).to eq(
+        @klass.new([false, false, false, true, true, false])
+        )
+    end
+  end
+end
+
+describe "Arel-like syntax" do
+  describe "comparison operators" do
+    describe Daru::Vector do
+      before do
+        @vector = Daru::Vector.new([23,51,1214,352,32,11])
+        @comparator = Daru::Vector.new([45,22,1214,55,32,9])
+        @klass = Daru::Core::Query::BoolArray
+      end
+
+      context "#eq" do
+        it "accepts scalar value" do
+          expect(@vector.eq(352)).to eq(
+            @klass.new([false,false,false,true,false,false]))
+        end
+
+        it "accepts vector and compares corrensponding elements" do
+          expect(@vector.eq(@comparator)).to eq(
+            @klass.new([false,false,true,false,true,false]))
+        end
+      end
+
+      context "#not_eq" do
+        it "accepts scalar value" do
+          expect(@vector.not_eq(51)).to eq(
+            @klass.new([true, false, true, true, true, true]))
+        end
+
+        it "accepts vector and compares corrensponding elements" do
+          expect(@vector.not_eq(@comparator)).to eq(
+            @klass.new([true, true, false, true, false, true]))
+        end
+      end
+
+      context "#lt" do
+        it "accepts scalar value" do
+          expect(@vector.lt(51)).to eq(
+            @klass.new([true, false, false, false, true, true]))
+        end
+
+        it "accepts vector and compares corrensponding elements" do
+          expect(@vector.lt(@comparator)).to eq(
+            @klass.new([true,false,false,false,false,false]))
+        end
+      end
+
+      context "#lteq" do
+        it "accepts scalar value" do
+          expect(@vector.lteq(51)).to eq(
+            @klass.new([true, true, false, false, true, true]))
+        end
+
+        it "accepts vector and compares corrensponding elements" do
+          expect(@vector.lteq(@comparator)).to eq(
+            @klass.new([true,false,true,false,true,false]))
+        end
+      end
+
+      context "#mt" do
+        it "accepts scalar value" do
+          expect(@vector.mt(51)).to eq(
+            @klass.new([false, false, true, true, false, false]))
+        end
+
+        it "accepts vector and compares corrensponding elements" do
+          expect(@vector.mt(@comparator)).to eq(
+            @klass.new([false,true,false,true,false,true]))
+        end
+      end
+
+      context "#mteq" do
+        it "accepts scalar value" do
+          expect(@vector.mteq(51)).to eq(
+            @klass.new([false, true, true, true, false, false]))
+        end
+
+        it "accepts vector and compares corrensponding elements" do
+          expect(@vector.mteq(@comparator)).to eq(
+            @klass.new([false,true,true,true,true,true]))
+        end
+      end
+
+      context "#in" do
+        it "checks if any of elements in the arg are present in the vector" do
+          expect(@vector.in([23,55,1,33,32])).to eq(
+            @klass.new([true, false, false, false, true, false]))
+        end
+      end
+    end
+  end
+
+  describe "where clause" do
+    context Daru::DataFrame do
+      before do
+        @df = Daru::DataFrame.new({
+          number: [1,2,3,4,5,6],
+          sym: [:one, :two, :three, :four, :five, :six],
+          names: ['sameer', 'john', 'james', 'omisha', 'priyanka', 'shravan']
+        })
+      end
+
+      it "accepts simple single eq statement" do
+        answer = Daru::DataFrame.new({
+          number: [4],
+          sym: [:four],
+          names: ['omisha']
+          }, index: Daru::Index.new([3])
+        )
+        expect(@df.where(@df[:number].eq(4))).to eq(answer)
+      end
+
+      it "accepts somewhat complex comparison operator chaining" do
+        answer = Daru::DataFrame.new({
+          number: [3,4],
+          sym: [:three, :four],
+          names: ['james', 'omisha']
+        }, index: Daru::Index.new([2,3]))
+        expect(
+          @df.where (@df[:names].eq('james') | @df[:sym].eq(:four))
+          ).to eq(answer)
+      end
+    end
+
+    context Daru::Vector do
+      before do
+        @vector = Daru::Vector.new([2,5,1,22,51,4])
+      end
+
+      it "accepts a simple single statement" do
+        expect(@vector.where(@vector.lt(10))).to eq(
+          Daru::Vector.new([2,5,1,4], index: Daru::Index.new([0,1,2,5])))
+      end
+
+      it "accepts somewhat complex operator chaining" do
+        expect(@vector.where((@vector.lt(6) | @vector.eq(51)))).to eq(
+          Daru::Vector.new([2,5,1,51,4], index: Daru::Index.new([0,1,2,4,5])))
+      end
+    end
+  end
+end

data/spec/dataframe_spec.rb

@@ -20,12 +20,12 @@ describe Daru::DataFrame do
       [:c,:two,:foo],
       [:c,:two,:bar]
     ]
-    @multi_index = Daru::MultiIndex.new(tuples)
+    @multi_index = Daru::MultiIndex.from_tuples(tuples)
 
     @vector_arry1 = [11,12,13,14,11,12,13,14,11,12,13,14]
     @vector_arry2 = [1,2,3,4,1,2,3,4,1,2,3,4]
 
-    @order_mi = Daru::MultiIndex.new([
+    @order_mi = Daru::MultiIndex.from_tuples([
       [:a,:one,:bar],
       [:a,:two,:baz],
       [:b,:two,:foo],
@@ -54,7 +54,7 @@ describe Daru::DataFrame do
 
         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])
-        expect(df.vector[:a]) .to eq(Daru::Vector.new [1,1,1,1])
+        expect(df[:a]) .to eq(Daru::Vector.new [1,1,1,1])
       end
 
       it "creates a DataFrame from Vector rows" do
@@ -64,17 +64,18 @@ describe Daru::DataFrame do
 
         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])
-        expect(df.vector[:a]) .to eq(Daru::Vector.new [1,1,1,1])
+        expect(df[:a]) .to eq(Daru::Vector.new [1,1,1,1])
       end
     end
 
     context Daru::MultiIndex do
       it "creates a DataFrame from rows" do
-        df = Daru::DataFrame.rows(@rows*3, index: @multi_index, order: [:a,:b,:c,:d,:e])
+        df = Daru::DataFrame.rows(
+          @rows*3, index: @multi_index, order: [:a,:b,:c,:d,:e])
 
         expect(df.index)     .to eq(@multi_index)
         expect(df.vectors)   .to eq(Daru::Index.new([:a,:b,:c,:d,:e]))
-        expect(df.vector[:a]).to eq(Daru::Vector.new([1]*12, index: @multi_index))
+        expect(df[:a]).to eq(Daru::Vector.new([1]*12, index: @multi_index))
       end
 
       it "crates a DataFrame from rows (MultiIndex order)" do
@@ -84,7 +85,7 @@ describe Daru::DataFrame do
           [13, 3, 13, 3], 
           [14, 4, 14, 4]
         ]
-        index = Daru::MultiIndex.new([
+        index = Daru::MultiIndex.from_tuples([
           [:one,:bar],
           [:one,:baz],
           [:two,:foo],
@@ -94,7 +95,7 @@ describe Daru::DataFrame do
         df = Daru::DataFrame.rows(rows, index: index, order: @order_mi)
         expect(df.index)  .to eq(index)
         expect(df.vectors).to eq(@order_mi)
-        expect(df.vector[:a, :one, :bar]).to eq(Daru::Vector.new([11,12,13,14],
+        expect(df[:a, :one, :bar]).to eq(Daru::Vector.new([11,12,13,14],
           index: index))
       end
 
@@ -106,7 +107,7 @@ describe Daru::DataFrame do
 
         expect(df.index).to eq(Daru::Index.new(Array.new(rows.size) { |i| i }))
         expect(df.vectors).to eq(@multi_index)
-        expect(df.vector[:a,:one,:bar]).to eq(Daru::Vector.new([1]*12))
+        expect(df[:a,:one,:bar]).to eq(Daru::Vector.new([1]*12))
       end
     end
   end
@@ -275,7 +276,7 @@ describe Daru::DataFrame do
         expect(df[:c].object_id).to eq(c.object_id)
       end
 
-      it "allows creation of empty dataframe with only order", focus: true do
+      it "allows creation of empty dataframe with only order" do
         df = Daru::DataFrame.new({}, order: [:a, :b, :c])
         df[:a] = Daru::Vector.new([1,2,3,4,5,6])
 
@@ -317,7 +318,7 @@ describe Daru::DataFrame do
         df = Daru::DataFrame.new({}, order: @order_mi)
 
         expect(df.vectors).to eq(@order_mi)
-        expect(df.vector[:a, :one, :bar]).to eq(Daru::Vector.new([]))
+        expect(df[:a, :one, :bar]).to eq(Daru::Vector.new([]))
       end
 
       it "creates from Hash" do
@@ -330,7 +331,7 @@ describe Daru::DataFrame do
 
         expect(df.index)               .to eq(@multi_index)
         expect(df.vectors)             .to eq(@order_mi)
-        expect(df.vector[:a,:one,:bar]).to eq(Daru::Vector.new(@vector_arry1, 
+        expect(df[:a,:one,:bar]).to eq(Daru::Vector.new(@vector_arry1, 
           index: @multi_index))
       end
 
@@ -344,7 +345,7 @@ describe Daru::DataFrame do
 
         expect(df.index)  .to eq(@multi_index)
         expect(df.vectors).to eq(@order_mi)
-        expect(df.vector[:a, :one, :bar]).to eq(Daru::Vector.new(@vector_arry1, 
+        expect(df[:a, :one, :bar]).to eq(Daru::Vector.new(@vector_arry1, 
           index: @multi_index))
       end
 
@@ -358,19 +359,19 @@ describe Daru::DataFrame do
       it "aligns MultiIndexes properly" do
         pending
         mi_a = @order_mi
-        mi_b = Daru::MultiIndex.new([
+        mi_b = Daru::MultiIndex.from_tuples([
           [:b,:one,:foo],
           [:a,:one,:bar],
           [:b,:two,:foo],
           [:a,:one,:baz]
         ])
-        mi_sorted = Daru::MultiIndex.new([
+        mi_sorted = Daru::MultiIndex.from_tuples([
           [:a, :one, :bar], 
           [:a, :one, :baz], 
           [:b, :one, :foo], 
           [:b, :two, :foo]
         ])
-        order = Daru::MultiIndex.new([
+        order = Daru::MultiIndex.from_tuples([
           [:pee, :que],
           [:pee, :poo]
         ])
@@ -394,7 +395,7 @@ describe Daru::DataFrame do
     end
   end
 
-  context "#[:vector]" do
+  context "#[]" do
     context Daru::Index do
       before :each do
         @df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
@@ -403,7 +404,7 @@ describe Daru::DataFrame do
       end
 
       it "returns a Vector" do
-        expect(@df[:a, :vector]).to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
+        expect(@df[:a]).to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
       end
 
       it "returns a Vector by default" do
@@ -415,11 +416,11 @@ describe Daru::DataFrame do
         temp = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]}, 
           order: [:a, :b], index: [:one, :two, :three, :four, :five])
 
-        expect(@df[:a, :b, :vector]).to eq(temp)
+        expect(@df[:a, :b]).to eq(temp)
       end
 
       it "accesses vector with Integer index" do
-        expect(@df[0, :vector]).to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
+        expect(@df[0]).to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
       end
 
       it "returns a subset of DataFrame when specified range" do
@@ -432,41 +433,35 @@ describe Daru::DataFrame do
     end
 
     context Daru::MultiIndex do
-      # See #vector
-    end
-  end
-
-  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], 
-          c: [11,22,33,44,55]}, 
-          order: [:a, :b, :c], 
-          index: [:one, :two, :three, :four, :five])
+      it "accesses vector with an integer index" do
+        expect(@df_mi[0]).to eq(
+          Daru::Vector.new(@vector_arry1, index: @multi_index))
       end
 
-      it "returns a row with the given index" do
-        expect(@df[:one, :row]).to eq([1,11,11].dv(:one, [:a, :b, :c]))
+      it "returns a vector when specifying full tuple" do
+        expect(@df_mi[:a, :one, :bar]).to eq(
+          Daru::Vector.new(@vector_arry1, index: @multi_index))
       end
 
-      it "returns a row with given Integer index" do
-        expect(@df[0, :row]).to eq([1,11,11].dv(:one, [:a, :b, :c]))
+      it "returns DataFrame when specified first layer of MultiIndex" do
+        sub_order = Daru::MultiIndex.from_tuples([
+          [:one, :bar],
+          [:two, :baz]
+          ])
+        expect(@df_mi[:a]).to eq(Daru::DataFrame.new([
+          @vector_arry1,
+          @vector_arry2
+        ], index: @multi_index, order: sub_order))
       end
 
-      it "returns a row with given Integer index for default index-less DataFrame" do
-        df = 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])
-
-        expect(df[0, :row]).to eq([1,11,11].dv(nil, [:a, :b, :c]))
+      it "returns a Vector if the last level of MultiIndex is tracked" do
+        expect(@df_mi[:a, :one]).to eq(
+          Daru::Vector.new(@vector_arry1, index: @multi_index))
       end
     end
-
-    context Daru::MultiIndex do
-      # See #row
-    end
   end
 
-  context "#[:vector]=" do
+  context "#[]=" do
     context Daru::Index do
       before :each do
         @df = Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5], 
@@ -474,46 +469,55 @@ describe Daru::DataFrame do
           index: [:one, :two, :three, :four, :five])
       end
 
+      it "assigns directly with the []= operator" do
+        @data_frame[:a] = [100,200,300,400,500]
+        expect(@data_frame).to eq(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
+
       it "appends an Array as a Daru::Vector" do
-        @df[:d, :vector] = [69,99,108,85,49]
+        @df[:d] = [69,99,108,85,49]
 
         expect(@df.d.class).to eq(Daru::Vector)
       end
 
       it "replaces an already present vector" do
-        @df[:a, :vector] = [69,99,108,85,49].dv(nil, [:one, :two, :three, :four, :five])
+        @df[:a] = [69,99,108,85,49].dv(nil, [:one, :two, :three, :four, :five])
 
         expect(@df.a).to eq([69,99,108,85,49].dv(nil, [:one, :two, :three, :four, :five]))
       end
 
       it "appends a new vector to the DataFrame" do
-        @df[:woo, :vector] = [69,99,108,85,49].dv(nil, [:one, :two, :three, :four, :five])
+        @df[:woo] = [69,99,108,85,49].dv(nil, [:one, :two, :three, :four, :five])
 
         expect(@df.vectors).to eq([:a, :b, :c, :woo].to_index)
       end
 
       it "creates an index for the new vector if not specified" do
-        @df[:woo, :vector] = [69,99,108,85,49]
+        @df[:woo] = [69,99,108,85,49]
 
         expect(@df.woo.index).to eq([:one, :two, :three, :four, :five].to_index)
       end   
 
       it "matches index of vector to be inserted with the DataFrame index" do
-        @df[:shankar, :vector] = [69,99,108,85,49].dv(:shankar, [:two, :one, :three, :five, :four])
+        @df[:shankar] = [69,99,108,85,49].dv(:shankar, [:two, :one, :three, :five, :four])
 
         expect(@df.shankar).to eq([99,69,108,49,85].dv(:shankar, 
           [:one, :two, :three, :four, :five]))
       end
 
       it "matches index of vector to be inserted, inserting nils where no match found" do
-        @df.vector[:shankar] = [1,2,3].dv(:shankar, [:one, :james, :hetfield])
+        @df[:shankar] = [1,2,3].dv(:shankar, [:one, :james, :hetfield])
 
         expect(@df.shankar).to eq([1,nil,nil,nil,nil].dv(:shankar, [:one, :two, :three, :four, :five]))
       end
 
       it "raises error for Array assignment of wrong length" do
         expect{
-          @df.vector[:shiva] = [1,2,3]
+          @df[:shiva] = [1,2,3]
           }.to raise_error
       end
 
@@ -521,23 +525,6 @@ describe Daru::DataFrame do
         # TODO
       end
     end
-    
-    context Daru::MultiIndex do
-      pending
-    end
-  end
-
-  context "#[]=" do
-    context Daru::Index do
-      it "assigns directly with the []= operator" do
-        @data_frame[:a] = [100,200,300,400,500]
-        expect(@data_frame).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
-    end
 
     context Daru::MultiIndex do
       it "raises error when incomplete index specified but index is absent" do
@@ -547,7 +534,6 @@ describe Daru::DataFrame do
       end
 
       it "assigns all sub-indexes when a top level index is specified" do
-        pending
         @df_mi[:a] = [100,200,300,400,100,200,300,400,100,200,300,400]
         
         expect(@df_mi).to eq(Daru::DataFrame.new([
@@ -558,8 +544,7 @@ describe Daru::DataFrame do
       end
 
       it "creates a new vector when full index specfied" do
-        pending
-        order = Daru::MultiIndex.new([
+        order = Daru::MultiIndex.from_tuples([
           [:a,:one,:bar],
           [:a,:two,:baz],
           [:b,:two,:foo],
@@ -579,7 +564,7 @@ describe Daru::DataFrame do
     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], 
@@ -590,33 +575,39 @@ describe Daru::DataFrame do
       it "assigns specified row when Array" do
         @df.row[:one] = [49, 99, 59]
 
-        expect(@df[:one, :row])      .to eq([49, 99, 59].dv(:one, [:a, :b, :c]))
-        expect(@df[:one, :row].index).to eq([:a, :b, :c].to_index)
-        expect(@df[:one, :row].name) .to eq(:one)
+        expect(@df.row[:one])      .to eq([49, 99, 59].dv(:one, [:a, :b, :c]))
+        expect(@df.row[:one].index).to eq([:a, :b, :c].to_index)
+        expect(@df.row[:one].name) .to eq(:one)
       end
 
       it "assigns specified row when DV" do
-        @df[:one, :row] = [49, 99, 59].dv(nil, [:a, :b, :c])
+        @df.row[:one] = [49, 99, 59].dv(nil, [:a, :b, :c])
 
-        expect(@df[:one, :row]).to eq([49, 99, 59].dv(:one, [:a, :b, :c]))
+        expect(@df.row[:one]).to eq([49, 99, 59].dv(:one, [:a, :b, :c]))
+      end
+
+      it "assigns correct elements when Vector of different index" do
+        @df.row[:one] = Daru::Vector.new([44,62,11], index: [:b,:f,:a])
+
+        expect(@df.row[:one]).to eq(Daru::Vector.new([11,44,nil], index: [:a,:b,:c]))
       end
 
       it "creates a new row from an Array" do
         @df.row[:patekar] = [9,2,11]
 
-        expect(@df[:patekar, :row]).to eq([9,2,11].dv(:patekar, [:a, :b, :c]))
+        expect(@df.row[:patekar]).to eq([9,2,11].dv(:patekar, [:a, :b, :c]))
       end
 
       it "creates a new row from a DV" do
         @df.row[:patekar] = [9,2,11].dv(nil, [:a, :b, :c])
 
-        expect(@df[:patekar, :row]).to eq([9,2,11].dv(:patekar, [:a, :b, :c]))
+        expect(@df.row[:patekar]).to eq([9,2,11].dv(:patekar, [:a, :b, :c]))
       end
 
       it "creates a new row from numeric row index and named DV" do
         @df.row[2] = [9,2,11].dv(nil, [:a, :b, :c])
 
-        expect(@df[2, :row]).to eq([9,2,11].dv(nil, [:a, :b, :c]))
+        expect(@df.row[2]).to eq([9,2,11].dv(nil, [:a, :b, :c]))
       end
 
       it "correctly aligns assigned DV by index" do
@@ -685,7 +676,22 @@ describe Daru::DataFrame do
             c: [11,22,33]}, order: [:a, :b, :c], 
             index: [:one, :two, :three])
           )
-      end      
+      end
+
+      it "returns a row with the given index" do
+        expect(@df.row[:one]).to eq([1,11,11].dv(:one, [:a, :b, :c]))
+      end
+
+      it "returns a row with given Integer index" do
+        expect(@df.row[0]).to eq([1,11,11].dv(:one, [:a, :b, :c]))
+      end
+
+      it "returns a row with given Integer index for default index-less DataFrame" do
+        df = 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])
+
+        expect(df.row[0]).to eq([1,11,11].dv(nil, [:a, :b, :c]))
+      end    
     end
 
     context Daru::MultiIndex do
@@ -694,22 +700,16 @@ describe Daru::DataFrame do
       end
 
       it "returns a DataFrame when specifying numeric range" do
-        sub_index = Daru::MultiIndex.new([
+        sub_index = Daru::MultiIndex.from_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]
+          [:a,:one,:baz]
         ])
 
         expect(@df_mi.row[0..1]).to eq(Daru::DataFrame.new([
-          [11,12,13,14,11,12,13,14],
-          [1,2,3,4,1,2,3,4],
-          [11,12,13,14,11,12,13,14],
-          [1,2,3,4,1,2,3,4]
+          [11,12],
+          [1,2],
+          [11,12],
+          [1,2]
         ], order: @order_mi, index: sub_index, name: :numeric_range))
       end
 
@@ -718,7 +718,7 @@ describe Daru::DataFrame do
       end
 
       it "returns DataFrame when specifying first layer of MultiIndex" do
-        sub_index = Daru::MultiIndex.new([
+        sub_index = Daru::MultiIndex.from_tuples([
           [:one,:bar],
           [:one,:baz],
           [:two,:foo],
@@ -733,7 +733,7 @@ describe Daru::DataFrame do
       end
 
       it "returns DataFrame when specifying first and second layer of MultiIndex" do
-        sub_index = Daru::MultiIndex.new([
+        sub_index = Daru::MultiIndex.from_tuples([
           [:bar],
           [:baz]
         ])
@@ -760,48 +760,6 @@ describe Daru::DataFrame do
     end
   end
 
-  context "#vector" do
-    context Daru::Index do
-      it "appends an Array as a Daru::Vector" do
-        @data_frame[:d, :vector] = [69,99,108,85,49]
-
-        expect(@data_frame.d.class).to eq(Daru::Vector)
-      end
-    end
-
-    context Daru::MultiIndex do
-      it "accesses vector with an integer index" do
-        expect(@df_mi.vector[0]).to eq(Daru::Vector.new(@vector_arry1,
-          index: @multi_index))
-      end
-
-      it "returns a vector when specifying full tuple" do
-        expect(@df_mi.vector[:a, :one, :bar]).to eq(Daru::Vector.new(@vector_arry1,
-          index: @multi_index))
-      end
-
-      it "returns DataFrame when specified first layer of MultiIndex" do
-        sub_order = Daru::MultiIndex.new([
-          [:one, :bar],
-          [:two, :baz]
-          ])
-        expect(@df_mi.vector[:a]).to eq(Daru::DataFrame.new([
-          @vector_arry1,
-          @vector_arry2
-        ], index: @multi_index, order: sub_order))
-      end
-
-      it "returns DataFrame when specified first and second layer of MultiIndex" do
-        sub_order = Daru::MultiIndex.new([
-          [:bar]
-        ])
-        expect(@df_mi.vector[:a, :one]).to eq(Daru::DataFrame.new([
-          @vector_arry1
-        ], index: @multi_index, order: sub_order))
-      end
-    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]}, 
@@ -824,7 +782,7 @@ describe Daru::DataFrame do
         expect(clo.index.object_id)  .not_to eq(@data_frame.object_id)
 
         @data_frame.each_vector_with_index do |vector, index|
-          expect(vector.object_id).not_to eq(clo.vector[index].object_id)
+          expect(vector.object_id).not_to eq(clo[index].object_id)
         end
       end
     end
@@ -1092,18 +1050,14 @@ describe Daru::DataFrame do
                 index: [:one, :two, :three, :four, :five]))    
       end
     end
-
-    context Daru::MultiIndex do
-      pending
-    end
   end
 
   context "#delete_row" do
     it "deletes the specified row" do
-      @data_frame.delete_row :one
+      @data_frame.delete_row :three
 
-      expect(@data_frame).to eq(Daru::DataFrame.new({b: [12,13,14,15], a: [2,3,4,5], 
-      c: [22,33,44,55]}, order: [:a, :b, :c], index: [:two, :three, :four, :five]))
+      expect(@data_frame).to eq(Daru::DataFrame.new({b: [11,12,14,15], a: [1,2,4,5], 
+      c: [11,22,44,55]}, order: [:a, :b, :c], index: [:one, :two, :four, :five]))
     end
   end
 
@@ -1161,10 +1115,6 @@ describe Daru::DataFrame do
         expect(a).to eq(Daru::DataFrame.new({a: [2], b: [3]}, order: [:a, :b], index: [1]))
       end
     end
-
-    context Daru::MultiIndex do
-      pending
-    end
   end
 
   context "#filter_vectors" do
@@ -1179,10 +1129,6 @@ describe Daru::DataFrame do
         expect(a).to eq(Daru::DataFrame.new({a: [1,2,3]}))
       end
     end
-
-    context Daru::MultiIndex do
-      pending
-    end
   end
 
   context "#to_a" do
@@ -1321,79 +1267,86 @@ describe Daru::DataFrame do
         @df_mi.sort([[:a,:one,:bar]])
       end
     end
-  end 
+  end
 
-  context "#reindex" do
-    it "sets a new sequential index for DF and its underlying vectors" do
-      a = @data_frame.reindex(:seq)
+  context "#index=" do
+    before :each do
+      @df = Daru::DataFrame.new({
+        a: [1,2,3,4,5],
+        b: [11,22,33,44,55],
+        c: %w(a b c d e)
+      })
+    end
 
-      expect(a).to eq(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]))
-      expect(a).to_not eq(@data_frame)
+    it "simply reassigns the index" do
+      @df.index = Daru::Index.new(['4','foo', :bar, 0, 23])
+      expect(@df.row['foo']).to eq(Daru::Vector.new([2,22,'b'], index: [:a,:b,:c]))
+    end
 
-      expect(a.a.index).to eq(Daru::Index.new(5))
-      expect(a.b.index).to eq(Daru::Index.new(5))
-      expect(a.c.index).to eq(Daru::Index.new(5))
+    it "raises error for improper length index" do
+      expect {
+        @df.index = Daru::Index.new([1,2])
+      }.to raise_error(ArgumentError)
     end
+  end
 
-    it "sets a new index for the data frame and its underlying vectors" do
-      a = @data_frame.reindex([:a,:b,:c,:d,:e])
+  context "#vectors=" do
+    before :each do
+      @df = Daru::DataFrame.new({
+        a: [1,2,3,4,5],
+        b: [11,22,33,44,55],
+        c: %w(a b c d e)
+      })
+    end
 
-      expect(a).to eq(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: [:a,:b,:c,:d,:e]))
-      expect(a).to_not eq(@data_frame)
+    it "simply reassigns vectors" do
+      @df.vectors = Daru::Index.new(['b',0,'m'])
 
-      expect(a.a.index).to eq(Daru::Index.new([:a,:b,:c,:d,:e]))
-      expect(a.b.index).to eq(Daru::Index.new([:a,:b,:c,:d,:e]))
-      expect(a.c.index).to eq(Daru::Index.new([:a,:b,:c,:d,:e]))
+      expect(@df.vectors).to eq(Daru::Index.new(['b',0,'m']))
+      expect(@df['b']).to eq(Daru::Vector.new([1,2,3,4,5]))
+      expect(@df[0]).to eq(Daru::Vector.new([11,22,33,44,55]))
+      expect(@df['m']).to eq(Daru::Vector.new(%w(a b c d e)))
     end
-  end
 
-  context "#reindex!" do
-    context Daru::Index do
-      it "sets a new sequential index for DF and its underlying vectors" do
-        expect(@data_frame.reindex!(:seq)).to eq(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]))
-        expect(@data_frame.a.index).to eq(Daru::Index.new(5))
-        expect(@data_frame.b.index).to eq(Daru::Index.new(5))
-        expect(@data_frame.c.index).to eq(Daru::Index.new(5))
-      end
-
-      it "sets a new index for the data frame and its underlying vectors" do
-        expect(@data_frame.reindex!([:a,:b,:c,:d,:e])).to eq(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: [:a,:b,:c,:d,:e]))
-        expect(@data_frame.a.index).to eq(Daru::Index.new([:a,:b,:c,:d,:e]))
-        expect(@data_frame.b.index).to eq(Daru::Index.new([:a,:b,:c,:d,:e]))
-        expect(@data_frame.c.index).to eq(Daru::Index.new([:a,:b,:c,:d,:e]))
-      end  
+    it "raises error for improper length index" do
+      expect {
+        @df.vectors = Daru::Index.new([1,2,'3',4,'5'])
+      }.to raise_error(ArgumentError)
     end
-
-    context Daru::MultiIndex do
-      pending "feature manually tested. write tests"
-    end  
   end
 
-  context "#reindex_vectors!" do
-    before :each do
-      @df = Daru::DataFrame.new({
+  context "#reindex" do
+    it "re indexes and aligns accordingly" do
+      df = Daru::DataFrame.new({
         a: [1,2,3,4,5],
         b: [11,22,33,44,55],
         c: %w(a b c d e)
       })
+      
+      ans = df.reindex(Daru::Index.new([1,3,0,8,2]))
+      expect(ans).to eq(Daru::DataFrame.new({
+        a: [2,4,1,nil,3],
+        b: [22,44,11,nil,33],
+        c: ['b','d','a',nil,'c']
+        }, index: Daru::Index.new([1,3,0,8,2])))
+      expect(ans).to_not eq(df)
     end
+  end
 
-    it "changes names of vectors" do
-      ans = Daru::DataFrame.new({
+  context "#reindex_vectors" do
+    it "re indexes vectors and aligns accordingly" do
+      df = Daru::DataFrame.new({
         a: [1,2,3,4,5],
         b: [11,22,33,44,55],
         c: %w(a b c d e)
-      }, order: [:b, :c, :a])
+      })
 
-      expect(@df.reindex_vectors!([:b,:c,:a])).to eq(Daru::Index.new([:b,:c,:a], [1,2,0]))
-      expect(@df[:a]).to eq(Daru::Vector.new([1,2,3,4,5]))
-      expect(@df[:c]).to eq(Daru::Vector.new(%w(a b c d e)))
+      ans = df.reindex_vectors(Daru::Index.new([:b, 'a', :a]))
+      expect(ans).to eq(Daru::DataFrame.new({
+        :b  => [11,22,33,44,55],
+        'a' => [nil, nil, nil, nil, nil],
+        :a  => [1,2,3,4,5]
+      }, order: [:b, 'a', :a]))
     end
   end
 
@@ -1476,16 +1429,16 @@ describe Daru::DataFrame do
       expect(@df.pivot_table(index: [:a])).to eq(Daru::DataFrame.new({
         d: [5.5,2.2],
         e: [11.0,4.4]
-      }, index: [:bar, :foo]))
+      }, index: ['bar', 'foo']))
     end
 
     it "creates row index as per (double) index argument and default aggregates to mean" do
-      agg_mi = Daru::MultiIndex.new(
+      agg_mi = Daru::MultiIndex.from_tuples(
         [        
-          [:bar, :large],
-          [:bar, :small],
-          [:foo, :large],
-          [:foo, :small]
+          ['bar', 'large'],
+          ['bar', 'small'],
+          ['foo', 'large'],
+          ['foo', 'small']
         ]
       )
       expect(@df.pivot_table(index: [:a, :c]).round(2)).to eq(Daru::DataFrame.new({
@@ -1495,46 +1448,48 @@ describe Daru::DataFrame do
     end
  
     it "creates row and vector index as per (single) index and (single) vectors args" do
-      agg_vectors = Daru::MultiIndex.new([
-        [:d, :one],
-        [:d, :two],
-        [:e, :one],
-        [:e, :two]
+      agg_vectors = Daru::MultiIndex.from_tuples([
+        [:d, 'one'],
+        [:d, 'two'],
+        [:e, 'one'],
+        [:e, 'two']
       ])
-      agg_index = Daru::MultiIndex.new(
+      agg_index = Daru::MultiIndex.from_tuples(
         [
-          [:bar],
-          [:foo]
+          ['bar'],
+          ['foo']
         ]
       )
-
-      expect(@df.pivot_table(index: [:a], vectors: [:b]).round(2)).to eq(Daru::DataFrame.new(
-        [
-          [4.5, 1.67],
-          [6.5,  3.0],
-          [9.0, 3.33],
-          [13,     6]
-        ], order: agg_vectors, index: agg_index))
+      
+      expect(@df.pivot_table(index: [:a], vectors: [:b]).round(2)).to eq(
+        Daru::DataFrame.new(
+          [
+            [4.5, 1.67],
+            [6.5,  3.0],
+            [9.0, 3.33],
+            [13,     6]
+          ], order: agg_vectors, index: agg_index)
+      )
     end
 
     it "creates row and vector index as per (single) index and (double) vector args" do
-      agg_vectors = Daru::MultiIndex.new(
+      agg_vectors = Daru::MultiIndex.from_tuples(
         [
-          [:d, :one, :large],
-          [:d, :one, :small],
-          [:d, :two, :large],
-          [:d, :two, :small],
-          [:e, :one, :large],
-          [:e, :one, :small],
-          [:e, :two, :large],
-          [:e, :two, :small]
+          [:d, 'one', 'large'],
+          [:d, 'one', 'small'],
+          [:d, 'two', 'large'],
+          [:d, 'two', 'small'],
+          [:e, 'one', 'large'],
+          [:e, 'one', 'small'],
+          [:e, 'two', 'large'],
+          [:e, 'two', 'small']
         ]
       )
 
-      agg_index = Daru::MultiIndex.new(
+      agg_index = Daru::MultiIndex.from_tuples(
         [
-          [:bar],
-          [:foo]
+          ['bar'],
+          ['foo']
         ]
       )
 
@@ -1553,21 +1508,21 @@ describe Daru::DataFrame do
     end
 
     it "creates row and vector index with (double) index and (double) vector args" do
-      agg_index = Daru::MultiIndex.new([
-        [:bar, 4],
-        [:bar, 5],
-        [:bar, 6],
-        [:bar, 7],
-        [:foo, 1],
-        [:foo, 2],
-        [:foo, 3]
+      agg_index = Daru::MultiIndex.from_tuples([
+        ['bar', 4],
+        ['bar', 5],
+        ['bar', 6],
+        ['bar', 7],
+        ['foo', 1],
+        ['foo', 2],
+        ['foo', 3]
       ])
 
-      agg_vectors = Daru::MultiIndex.new([
-        [:e, :one, :large],
-        [:e, :one, :small],
-        [:e, :two, :large],
-        [:e, :two, :small]
+      agg_vectors = Daru::MultiIndex.from_tuples([
+        [:e, 'one', 'large'],
+        [:e, 'one', 'small'],
+        [:e, 'two', 'large'],
+        [:e, 'two', 'small']
       ])
 
       expect(@df.pivot_table(index: [:a, :d], vectors: [:b, :c])).to eq(
@@ -1582,18 +1537,18 @@ describe Daru::DataFrame do
     end
 
     it "only aggregates over the vector specified in the values argument" do
-      agg_vectors = Daru::MultiIndex.new(
+      agg_vectors = Daru::MultiIndex.from_tuples(
         [
-          [:e, :one, :large],
-          [:e, :one, :small],
-          [:e, :two, :large],
-          [:e, :two, :small]
+          [:e, 'one', 'large'],
+          [:e, 'one', 'small'],
+          [:e, 'two', 'large'],
+          [:e, 'two', 'small']
         ]
       )
-      agg_index = Daru::MultiIndex.new(
+      agg_index = Daru::MultiIndex.from_tuples(
         [
-          [:bar],
-          [:foo]
+          ['bar'],
+          ['foo']
         ]
       )
       expect(@df.pivot_table(index: [:a], vectors: [:b, :c], values: :e)).to eq(
@@ -1609,18 +1564,18 @@ describe Daru::DataFrame do
     end
 
     it "overrides default aggregate function to aggregate over sum" do
-      agg_vectors = Daru::MultiIndex.new(
+      agg_vectors = Daru::MultiIndex.from_tuples(
         [
-          [:e, :one, :large],
-          [:e, :one, :small],
-          [:e, :two, :large],
-          [:e, :two, :small]
+          [:e, 'one', 'large'],
+          [:e, 'one', 'small'],
+          [:e, 'two', 'large'],
+          [:e, 'two', 'small']
         ]
       )
-      agg_index = Daru::MultiIndex.new(
+      agg_index = Daru::MultiIndex.from_tuples(
         [
-          [:bar],
-          [:foo]
+          ['bar'],
+          ['foo']
         ]
       )
       expect(@df.pivot_table(index: [:a], vectors: [:b, :c], values: :e, agg: :sum)).to eq(
@@ -1908,15 +1863,15 @@ describe Daru::DataFrame do
       df = Daru::DataFrame.crosstab_by_assignation(v1, v2, v3)
 
       expect(df[:_id].type).to eq(:object)
-      expect(df[:a].type).to eq(:numeric)
-      expect(df[:b].type).to eq(:numeric)
+      expect(df['a'].type).to eq(:numeric)
+      expect(df['b'].type).to eq(:numeric)
 
       ev_id = Daru::Vector.new %w(a b c)
       ev_a  = Daru::Vector.new [0, 0, 0]
       ev_b  = Daru::Vector.new [1, 1, 0]
       ev_c  = Daru::Vector.new [0, 1, 1]
       df2 = Daru::DataFrame.new({ 
-        :_id => ev_id, :a => ev_a, :b => ev_b, :c => ev_c })
+        :_id => ev_id, 'a' => ev_a, 'b' => ev_b, 'c' => ev_c })
 
       expect(df2).to eq(df)
     end
@@ -1929,19 +1884,21 @@ describe Daru::DataFrame do
         ['2', 'fred', 'green', 15, 'orange', 30, 'white', 20],
         ['3', 'alfred', nil, nil, nil, nil, nil, nil]
       ]
+
       df = Daru::DataFrame.rows(rows, 
-        order: [:id, :name, :car_color1, :car_value1, :car_color2, 
-          :car_value2, :car_color3, :car_value3])
+        order: ['id', 'name', 'car_color1', 'car_value1', 'car_color2', 
+          'car_value2', 'car_color3', 'car_value3'])
 
       ids     = Daru::Vector.new %w(1 1 2 2 2)
       colors  = Daru::Vector.new %w(red blue green orange white)
       values  = Daru::Vector.new [10, 20, 15, 30, 20]
       col_ids = Daru::Vector.new [1, 2, 1, 2, 3]
+
       df_expected = Daru::DataFrame.new({
-        :id => ids, :_col_id => col_ids, :color => colors, :value => values
-        }, order: [:id, :_col_id, :color, :value])
+        'id' => ids, '_col_id' => col_ids, 'color' => colors, 'value' => values
+        }, order: ['id', '_col_id', 'color', 'value'])
 
-      expect(df.one_to_many([:id], 'car_%v%n')).to eq(df_expected)
+      expect(df.one_to_many(['id'], 'car_%v%n')).to eq(df_expected)
     end
   end
 
@@ -2023,7 +1980,7 @@ describe Daru::DataFrame do
 
     context Daru::MultiIndex do
       before do
-        agg_vectors = Daru::MultiIndex.new(
+        agg_vectors = Daru::MultiIndex.from_tuples(
           [
             [:d, :one, :large],
             [:d, :one, :small],
@@ -2036,7 +1993,7 @@ describe Daru::DataFrame do
           ]
         )
 
-        agg_index = Daru::MultiIndex.new(
+        agg_index = Daru::MultiIndex.from_tuples(
           [
             [:bar],
             [:foo]
@@ -2057,7 +2014,7 @@ describe Daru::DataFrame do
       end
 
       it "returns numeric vectors" do
-        vectors = Daru::MultiIndex.new(
+        vectors = Daru::MultiIndex.from_tuples(
           [
             [:d, :one, :large],
             [:d, :two, :large],
@@ -2068,7 +2025,7 @@ describe Daru::DataFrame do
           ]
         )
 
-        index = Daru::MultiIndex.new(
+        index = Daru::MultiIndex.from_tuples(
           [
             [:bar],
             [:foo]
@@ -2089,4 +2046,45 @@ describe Daru::DataFrame do
       end
     end
   end
+
+  context "#set_index" do
+    before(:each) do
+      @df = Daru::DataFrame.new({
+        a: [1,2,3,4,5],
+        b: ['a','b','c','d','e'],
+        c: [11,22,33,44,55]
+        })
+    end
+
+    it "sets a particular column as the index and deletes that column" do
+      @df.set_index(:b)
+      expect(@df).to eq(
+        Daru::DataFrame.new({
+          a: [1,2,3,4,5],
+          c: [11,22,33,44,55]
+          }, index: ['a','b','c','d','e'])
+        )
+    end
+
+    it "sets a particular column as index but keeps that column" do
+      expect(@df.set_index(:c, keep: true)).to eq(
+        Daru::DataFrame.new({
+          a: [1,2,3,4,5],
+          b: ['a','b','c','d','e'],
+          c: [11,22,33,44,55]
+          }, index: [11,22,33,44,55]))
+      expect(@df[:c]).to eq(@df[:c])
+    end
+
+    it "raises error if all elements in the column aren't unique" do
+      jholu = Daru::DataFrame.new({
+        a: ['a','b','a'],
+        b: [1,2,4]
+        })
+
+      expect {
+        jholu.set_index(:a)
+      }.to raise_error(ArgumentError)
+    end
+  end
 end if mri?