daru 0.1.3.1 → 0.1.4

data/spec/core/group_by_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper.rb'
-
 describe Daru::Core::GroupBy do
   before do
     @df = Daru::DataFrame.new({
@@ -140,6 +138,44 @@ describe Daru::Core::GroupBy do
     end
   end
 
+  context '#each_group' do
+    it 'enumerates groups' do
+      ret = []
+      @dl_group.each_group { |g| ret << g }
+      expect(ret.count).to eq 6
+      expect(ret).to all be_a(Daru::DataFrame)
+      expect(ret.first).to eq(Daru::DataFrame.new({
+        a: ['bar'],
+        b: ['one'],
+        c: [2],
+        d: [22]
+        }, index: [1]
+      ))
+    end
+  end
+
+  context '#first' do
+    it 'gets the first row from each group' do
+      expect(@dl_group.first).to eq(Daru::DataFrame.new({
+        a: %w{bar bar   bar foo foo   foo },
+        b: %w{one three two one three two },
+        c:   [2  ,1    ,6  ,1  ,8    ,3   ],
+        d:   [22 ,44   ,66 ,11 ,88   ,33  ]
+      }, index: [1,3,5,0,7,2]))
+    end
+  end
+
+  context '#last' do
+    it 'gets the last row from each group' do
+      expect(@dl_group.last).to eq(Daru::DataFrame.new({
+        a: %w{bar bar   bar foo foo   foo },
+        b: %w{one three two one three two },
+        c:   [2  ,1    ,6  ,3  ,8    ,3   ],
+        d:   [22 ,44   ,66 ,77 ,88   ,55  ]
+      }, index: [1,3,5,6,7,4]))
+    end
+  end
+
   context "#aggregate" do
     pending
   end
@@ -191,6 +227,14 @@ describe Daru::Core::GroupBy do
     end
   end
 
+  [:median, :std, :max, :min].each do |numeric_method|
+    it "works somehow" do
+      expect(@sl_group.send(numeric_method).index).to eq @sl_index
+      expect(@dl_group.send(numeric_method).index).to eq @dl_multi_index
+      expect(@tl_group.send(numeric_method).index).to eq @tl_multi_index
+    end
+  end
+
   context "#product" do
     it "calculates product for single layer groups" do
       # TODO
@@ -351,5 +395,11 @@ describe Daru::Core::GroupBy do
       string_concat = lambda { |result, row| result += row[:b] }
       expect(@sl_group.reduce('', &string_concat)).to eq(Daru::Vector.new(['onethreetwo', 'onetwotwoonethree'], index: @sl_index))
     end
+
+    it "works with multi-indexes" do
+      string_concat = lambda { |result, row| result += row[:b] }
+      expect(@dl_group.reduce('', &string_concat)).to eq \
+        Daru::Vector.new(['one', 'three', 'two', 'oneone', 'three', 'twotwo'], index: @dl_multi_index)
+    end
   end
 end

data/spec/core/merge_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe Daru::DataFrame do
   context "#join" do
     before do
@@ -39,6 +37,16 @@ describe Daru::DataFrame do
       expect(@left.join(@right_many, how: :inner, on: [:id])).to eq(answer)
     end
 
+    it "performs an inner join of two dataframes that has many to many mapping" do
+      @left[:id].recode! { |v| v == 2 ? 1 : v }
+      answer = Daru::DataFrame.new({
+        :name_1 => ['Pirate', 'Pirate', 'Pirate', 'Pirate', 'Monkey', 'Monkey', 'Monkey', 'Monkey'],
+        :id => [1,1,1,1,1,1,1,1],
+        :name_2 => ['Rutabaga', 'Pirate', 'Darth Vader', 'Ninja', 'Rutabaga', 'Pirate', 'Darth Vader', 'Ninja']
+      }, order: [:name_1, :id, :name_2])
+      expect(@left.join(@right_many, how: :inner, on: [:id])).to eq(answer)
+    end
+
     it "performs a full outer join" do
       answer = Daru::DataFrame.new({
         :id_1 => [nil,2,3,1,nil,4],
@@ -48,6 +56,38 @@ describe Daru::DataFrame do
       expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
     end
 
+    it "performs a full outer join when the right join keys have nils" do
+      @right[:name].recode! { |v| v == 'Rutabaga' ? nil : v }
+      answer = Daru::DataFrame.new({
+        :id_1 => [nil, nil,2,3,1,4],
+        :name => [nil, "Darth Vader", "Monkey", "Ninja", "Pirate", "Spaghetti"],
+        :id_2 => [1,3,nil,4,2,nil]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
+    end
+
+    it "performs a full outer join when the left join keys have nils" do
+      @left[:name].recode! { |v| v == 'Monkey' ? nil : v }
+      answer = Daru::DataFrame.new({
+        :id_1 => [2,nil,3,1,nil,4],
+        :name => [nil, "Darth Vader", "Ninja", "Pirate", "Rutabaga", "Spaghetti"],
+        :id_2 => [nil,3,4,2,1,nil]
+      }, order: [:id_1, :name, :id_2])
+      expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
+    end
+
+    it "performs a full outer join when both left and right join keys have nils" do
+      @left[:name].recode! { |v| v == 'Monkey' ? nil : v }
+      @right[:name].recode! { |v| v == 'Rutabaga' ? nil : v }
+
+      answer = Daru::DataFrame.new({
+        :id_1 => [nil,2,nil,3,1,4],
+        :name => [nil, nil, "Darth Vader", "Ninja", "Pirate", "Spaghetti"],
+        :id_2 => [1,nil,3,4,2,nil]
+      }, 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 => [2,3,1,4],
@@ -77,5 +117,26 @@ describe Daru::DataFrame do
       expect(@left.join(@right, how: :right, on: [:name])).to eq(answer)
     end
 
+    it "raises if :on field are absent in one of dataframes" do
+      @right.vectors = [:id, :other_name]
+      expect { @left.join(@right, how: :right, on: [:name]) }.to \
+        raise_error(ArgumentError, /Both dataframes expected .* :name/)
+
+      expect { @left.join(@right, how: :right, on: [:other_name]) }.to \
+        raise_error(ArgumentError, /Both dataframes expected .* :other_name/)
+    end
+
+    it "is able to join by several :on fields" do
+      @left.gender = ['m', 'f', 'm', nil]
+      @right.gender = ['m', 'm', nil, 'f']
+
+      answer = Daru::DataFrame.new({
+        id_1: [1],
+        name: ['Pirate'],
+        gender: ['m'],
+        id_2: [2]
+      }, order: [:id_1, :name, :gender, :id_2])
+      expect(@left.join(@right, how: :inner, on: [:name, :gender])).to eq(answer)
+    end
   end
 end

data/spec/core/query_spec.rb

@@ -1,8 +1,6 @@
-require 'spec_helper'
-
 describe Daru::Core::Query::BoolArray do
   before do
-    @klass = Daru::Core::Query::BoolArray 
+    @klass = Daru::Core::Query::BoolArray
     @left = @klass.new([true, true, true, false, false, true])
     @right = @klass.new([false, false, false, false, true, false])
   end
@@ -28,94 +26,212 @@ describe Daru::Core::Query::BoolArray do
         )
     end
   end
+
+  context '#inspect' do
+    it 'is reasonable' do
+      expect(@left.inspect).to eq "#<Daru::Core::Query::BoolArray:#{@left.object_id} bool_arry=[true, true, true, false, false, true]>"
+    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]))
+      describe "non-categorical type" 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
-
-        it "accepts vector and compares corrensponding elements" do
-          expect(@vector.eq(@comparator)).to eq(
-            @klass.new([false,false,true,false,true,false]))
+  
+        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
-      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]))
+  
+        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
-
-        it "accepts vector and compares corrensponding elements" do
-          expect(@vector.not_eq(@comparator)).to eq(
-            @klass.new([true, true, false, true, false, true]))
+  
+        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
-      end
-
-      context "#lt" do
-        it "accepts scalar value" do
-          expect(@vector.lt(51)).to eq(
-            @klass.new([true, false, false, false, true, true]))
+  
+        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
-
-        it "accepts vector and compares corrensponding elements" do
-          expect(@vector.lt(@comparator)).to eq(
-            @klass.new([true,false,false,false,false,false]))
+  
+        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
-      end
-
-      context "#lteq" do
-        it "accepts scalar value" do
-          expect(@vector.lteq(51)).to eq(
-            @klass.new([true, true, false, false, true, true]))
+  
+        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
-
-        it "accepts vector and compares corrensponding elements" do
-          expect(@vector.lteq(@comparator)).to eq(
-            @klass.new([true,false,true,false,true,false]))
+  
+        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
+      
+      describe "categorical type" do
+        let(:dv) { Daru::Vector.new ['e', 'd', 'd', 'x', 'x'],
+          categories: ['a', 'x', 'c', 'd', 'e'], type: :category }
+        let(:comp) { Daru::Vector.new ['a', 'd', 'x', 'e', 'x'],
+          categories: ['a', 'x', 'c', 'd', 'e'], type: :category }
+        let(:query_bool_class) { Daru::Core::Query::BoolArray }
 
-      context "#mt" do
-        it "accepts scalar value" do
-          expect(@vector.mt(51)).to eq(
-            @klass.new([false, false, true, true, false, false]))
-        end
+        context "#eq" do
+          context "scalar" do
+            subject { dv.eq 'd' }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [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]))
+          context "vector" do
+            subject { dv.eq comp }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, true, false, false, true] }
+          end
         end
-      end
-
-      context "#mteq" do
-        it "accepts scalar value" do
-          expect(@vector.mteq(51)).to eq(
-            @klass.new([false, true, true, true, false, false]))
+  
+        context "#not_eq" do
+          context "scalar" do
+            subject { dv.not_eq 'd' }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, false, false, true, true] }
+          end
+          
+          context "vector" do
+            subject { dv.not_eq comp }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, false, true, true, false] }
+          end
         end
-
-        it "accepts vector and compares corrensponding elements" do
-          expect(@vector.mteq(@comparator)).to eq(
-            @klass.new([false,true,true,true,true,true]))
+  
+        context "#lt" do
+          context "scalar" do
+            subject { dv.lt 'd' }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, false, false, true, true] }
+          end
+          
+          context "vector" do
+            subject { dv.lt comp }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, false, false, true, false] }
+          end
         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]))
+  
+        context "#lteq" do
+          context "scalar" do
+            subject { dv.lteq 'd' }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, true, true, true, true] }
+          end
+          
+          context "vector" do
+            subject { dv.lteq comp }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [false, true, false, true, true] }
+          end
+        end
+  
+        context "#mt" do
+          context "scalar" do
+            subject { dv.mt 'd' }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, false, false, false, false] }
+          end
+          
+          context "vector" do
+            subject { dv.mt comp }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, false, true, false, false] }
+          end
+        end
+  
+        context "#mteq" do
+          context "scalar" do
+            subject { dv.mteq 'd' }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, true, true, false, false] }
+          end
+          
+          context "vector" do
+            subject { dv.mteq comp }
+            
+            it { is_expected.to be_a query_bool_class }
+            its(:to_a) { is_expected.to eq [true, true, true, false, true] }
+          end
         end
+  
+        # context "#in" do
+        #   subject { dv.in ['b', 'd'] }
+        #   it { is_expected.to be_a query_bool_class }
+        #   its(:to_a) { is_expected.to eq [false, true, true, true, true] }
+        # end
       end
     end
   end
@@ -153,18 +269,58 @@ describe "Arel-like syntax" do
     end
 
     context Daru::Vector do
-      before do
-        @vector = Daru::Vector.new([2,5,1,22,51,4])
+      context "non-categorical type" 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
-
-      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])))
+      
+      context "categorical type" do
+        let(:dv) { Daru::Vector.new ['a', 'c', 'x', 'x', 'c'],
+          categories: ['a', 'x', 'c'], type: :category }
+        
+        context "simple single statement" do
+          subject { dv.where(dv.lt('x')) }
+          
+          it { is_expected.to be_a Daru::Vector }
+          its(:type) { is_expected.to eq :category }
+          its(:to_a) { is_expected.to eq ['a'] }
+          its(:'index.to_a') { is_expected.to eq [0] }
+        end
+        
+        context "complex operator chaining" do
+          subject { dv.where((dv.lt('x') | dv.eq('c'))) }
+          
+          it { is_expected.to be_a Daru::Vector }
+          its(:type) { is_expected.to eq :category }
+          its(:to_a) { is_expected.to eq ['a', 'c', 'c'] }
+          its(:'index.to_a') { is_expected.to eq [0, 1, 4] }
+        end
+        
+        context "preserve categories" do
+          subject { dv.where((dv.lt('x') | dv.eq('c'))) }
+          
+          it { is_expected.to be_a Daru::Vector }
+          its(:type) { is_expected.to eq :category }
+          its(:to_a) { is_expected.to eq ['a', 'c', 'c'] }
+          its(:'index.to_a') { is_expected.to eq [0, 1, 4] }
+          its(:categories) { is_expected.to eq ['a', 'x', 'c'] }
+        end
       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])))
+      it "preserves name" do
+        named_vector = Daru::Vector.new([1,2,3], name: 'named')
+        expect(named_vector.where(named_vector.lteq(2)).name).to eq('named')
       end
     end
   end