daru 0.1.5 → 0.1.6

data/lib/daru/version.rb

@@ -1,3 +1,3 @@
 module Daru
-  VERSION = '0.1.5'.freeze
+  VERSION = '0.1.6'.freeze
 end

data/spec/category_spec.rb

@@ -383,13 +383,13 @@ describe Daru::Vector, "categorical" do
   context "#rename_categories" do
     context 'rename base category' do
       let(:dv) { Daru::Vector.new [:a, 1, :a, 1, :c], type: :category,
-        categories: [:a, :x, :y, :c, :b, 1]}    
+        categories: [:a, :x, :y, :c, :b, 1]}
       subject { dv.rename_categories :a => 1, 1 => 2 }
 
       it { is_expected.to be_a Daru::Vector }
       its(:to_a) { is_expected.to eq [1, 2, 1, 2, :c] }
       its(:categories) { is_expected.to eq [:x, :y, :c, :b, 1, 2] }
-      its(:base_category) { is_expected.to eq 1 }      
+      its(:base_category) { is_expected.to eq 1 }
     end
 
     context 'rename non-base category' do
@@ -1398,7 +1398,7 @@ describe Daru::Vector, "categorical" do
       index: 11..18, type: :category }
     context 'reject only nils' do
       subject { dv.reject_values nil }
-      
+
       it { is_expected.to be_a Daru::Vector }
       its(:type) { is_expected.to eq :category }
       its(:to_a) { is_expected.to eq [1, 3, :a, Float::NAN, Float::NAN, 1] }
@@ -1407,7 +1407,7 @@ describe Daru::Vector, "categorical" do
 
     context 'reject only float::NAN' do
       subject { dv.reject_values Float::NAN }
-      
+
       it { is_expected.to be_a Daru::Vector }
       its(:type) { is_expected.to eq :category }
       its(:to_a) { is_expected.to eq [1, nil, 3, :a, nil, 1] }
@@ -1422,7 +1422,7 @@ describe Daru::Vector, "categorical" do
       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, 20 }
 
@@ -1434,19 +1434,19 @@ describe Daru::Vector, "categorical" do
 
     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    
+    end
   end
 
   context '#include_values?' do
@@ -1484,27 +1484,27 @@ describe Daru::Vector, "categorical" do
           type: :category}
         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],
           type: :category}
         it { expect(dv.include_values? nil, Float::NAN).to eq true }
       end
-      
+
       context 'false' do
         let(:dv) { Daru::Vector.new [1, 2, 3],
           type: :category}
         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],
           type: :category }
         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],
           type: :category }
@@ -1525,12 +1525,12 @@ describe Daru::Vector, "categorical" do
     context Daru::Index do
       let(:dv) { Daru::Vector.new [1, 2, 1, 2, 3, nil, nil, Float::NAN],
         index: 11..18, type: :category }
-      
+
       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
       let(:mi) do
         Daru::MultiIndex.from_tuples([
@@ -1546,7 +1546,7 @@ describe Daru::Vector, "categorical" do
       end
       let(:dv) { Daru::Vector.new [1, 2, 1, 2, 3, nil, nil, Float::NAN],
         index: mi, type: :category }
-      
+
       subject { dv.indexes 1, 2, Float::NAN }
       it { is_expected.to be_a Array }
       it { is_expected.to eq(
@@ -1559,7 +1559,7 @@ describe Daru::Vector, "categorical" do
         ]) }
     end
   end
-  
+
   context '#replace_values' do
     subject do
       Daru::Vector.new(
@@ -1573,14 +1573,14 @@ describe Daru::Vector, "categorical" do
       its(:type) { is_expected.to eq :category }
       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(:type) { is_expected.to eq :category }
       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(:type) { is_expected.to eq :category }

data/spec/core/group_by_spec.rb

@@ -29,6 +29,7 @@ describe Daru::Core::GroupBy do
       ['foo', 'three', 8],
       ['foo', 'two'  , 3]
     ])
+
   end
 
   context 'with nil values' do
@@ -46,6 +47,34 @@ describe Daru::Core::GroupBy do
   end
 
   context "#initialize" do
+    let(:df_emp) { Daru::DataFrame.new(
+      employee: %w[John Jane Mark John Jane Mark],
+      month: %w[June June June July July July],
+      salary: [1000, 500, 700, 1200, 600, 600]
+    ) }
+    let(:employee_grp) { df_emp.group_by(:employee).df }
+    let(:mi_single) { Daru::MultiIndex.from_tuples([
+        ['Jane', 1], ['Jane', 4], ['John', 0],
+        ['John', 3], ['Mark', 2], ['Mark', 5]
+        ]
+      )}
+
+    let(:emp_month_grp) { df_emp.group_by([:employee, :month]).df }
+    let(:mi_double) { Daru::MultiIndex.from_tuples([
+        ['Jane', 'July', 4], ['Jane', 'June', 1], ['John', 'July', 3],
+        ['John', 'June', 0], ['Mark', 'July', 5], ['Mark', 'June', 2]
+        ]
+      )}
+
+    let(:emp_month_salary_grp) {
+      df_emp.group_by([:employee, :month, :salary]).df }
+    let(:mi_triple) { Daru::MultiIndex.from_tuples([
+        ['Jane', 'July', 600, 4], ['Jane', 'June', 500, 1],
+        ['John', 'July', 1200, 3], ['John', 'June', 1000, 0],
+        ['Mark', 'July', 600, 5], ['Mark', 'June', 700, 2]
+        ]
+      )}
+
     it "groups by a single tuple" do
       expect(@sl_group.groups).to eq({
         ['bar'] => [1,3,5],
@@ -53,6 +82,24 @@ describe Daru::Core::GroupBy do
       })
     end
 
+    it "returns dataframe with MultiIndex, groups by single layer hierarchy" do
+      expect(employee_grp).to eq(Daru::DataFrame.new({
+        month: ["June", "July", "June", "July", "June", "July"],
+        salary: [500, 600, 1000, 1200, 700, 600]
+        }, index: mi_single))
+    end
+
+    it "returns dataframe with MultiIndex, groups by double layer hierarchy" do
+      expect(emp_month_grp).to eq(Daru::DataFrame.new({
+        salary: [600, 500, 1200, 1000, 600, 700]
+        }, index: mi_double))
+    end
+
+    it "returns dataframe with MultiIndex, groups by triple layer hierarchy" do
+      expect(emp_month_salary_grp).to eq(Daru::DataFrame.new({
+        }, index: mi_triple))
+    end
+
     it "groups by a double layer hierarchy" do
       expect(@dl_group.groups).to eq({
         ['foo', 'one']   => [0,6],

data/spec/core/query_spec.rb

@@ -43,79 +43,79 @@ describe "Arel-like syntax" do
           @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(
@@ -123,7 +123,7 @@ describe "Arel-like syntax" do
           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 }
@@ -134,99 +134,99 @@ describe "Arel-like syntax" do
         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
 
           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
-  
+
         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
-  
+
         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
-  
+
         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 }
@@ -240,9 +240,9 @@ describe "Arel-like syntax" 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']
+          number: [1,2,3,4,5,6,Float::NAN],
+          sym: [:one, :two, :three, :four, :five, :six, :seven],
+          names: ['sameer', 'john', 'james', 'omisha', 'priyanka', 'shravan',nil]
         })
       end
 
@@ -267,6 +267,11 @@ describe "Arel-like syntax" do
           ).to eq(answer)
       end
 
+      let(:dv) { Daru::Vector.new([1,11,32,Float::NAN,nil]) }
+      it "handles empty data" do
+        expect(dv.where(dv.lt(14))).to eq(Daru::Vector.new([1,11]))
+      end
+
       it "does not give SystemStackError" do
         v = Daru::Vector.new [1]*300_000
         expect { v.where v.eq(1) }.not_to raise_error
@@ -276,45 +281,45 @@ describe "Arel-like syntax" do
     context Daru::Vector do
       context "non-categorical type" do
         before do
-          @vector = Daru::Vector.new([2,5,1,22,51,4])
+          @vector = Daru::Vector.new([2,5,1,22,51,4,nil,Float::NAN])
         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
-      
+
       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'] }