daru 0.1.5 → 0.3

data/lib/daru/version.rb

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

data/profile/vector_new.rb

@@ -0,0 +1,9 @@
+require_relative '_base'
+
+n = 40_0000
+idx = (1..n).to_a.map(&:to_s)
+
+
+__profile__ do
+  Daru::Vector.new(1..n, index: idx)
+end

data/spec/accessors/gsl_wrapper_spec.rb

@@ -1,50 +1,53 @@
-describe Daru::Accessors::GSLWrapper do
-  before :each do
-    @stub_context = Object.new
-    @gsl_wrapper = Daru::Accessors::GSLWrapper.new([1,2,3,4,5,6], @stub_context)
-  end
+if Daru.has_gsl?
+  describe Daru::Accessors::GSLWrapper do
+    before :each do
+      @stub_context = Object.new
+      @gsl_wrapper = Daru::Accessors::GSLWrapper.new([1,2,3,4,5,6], @stub_context)
+    end
 
-  context ".new" do
-    it "actually creates a GSL Vector" do
-      expect(@gsl_wrapper.data.class).to eq(GSL::Vector)
+    context ".new" do
+      it "actually creates a GSL Vector" do
+        expect(@gsl_wrapper.data.class).to eq(GSL::Vector)
+      end
     end
-  end
 
-  context "#mean" do
-    it "computes mean" do
-      expect(@gsl_wrapper.mean).to eq(3.5)
+    context "#mean" do
+      it "computes mean" do
+        expect(@gsl_wrapper.mean).to eq(3.5)
+      end
     end
-  end
 
-  context "#map!" do
-    it "destructively maps" do
-      expect(@gsl_wrapper.map! { |a| a += 1 }).to eq(
-        Daru::Accessors::GSLWrapper.new([2,3,4,5,6,7], @stub_context)
-      )
+    context "#map!" do
+      it "destructively maps" do
+        expect(@gsl_wrapper.map! { |a| a += 1 }).to eq(
+          Daru::Accessors::GSLWrapper.new([2,3,4,5,6,7], @stub_context)
+        )
+      end
     end
-  end
 
-  context "#delete_at" do
-    it "deletes at key" do
-      expect(@gsl_wrapper.delete_at(2)).to eq(3)
+    context "#delete_at" do
+      it "deletes at key" do
+        expect(@gsl_wrapper.delete_at(2)).to eq(3)
 
-      expect(@gsl_wrapper).to eq(
-        Daru::Accessors::GSLWrapper.new([1,2,4,5,6], @stub_context)
-      )
+        expect(@gsl_wrapper).to eq(
+          Daru::Accessors::GSLWrapper.new([1,2,4,5,6], @stub_context)
+        )
+      end
     end
-  end
 
-  context "#index" do
-    it "returns index of value" do
-      expect(@gsl_wrapper.index(3)).to eq(2)
+    context "#index" do
+      it "returns index of value" do
+        expect(@gsl_wrapper.index(3)).to eq(2)
+      end
     end
-  end
 
-  context "#push" do
-    it "appends element" do
-      expect(@gsl_wrapper.push(15)).to eq(
-        Daru::Accessors::GSLWrapper.new([1,2,3,4,5,6,15], @stub_context)
-      )
+    context "#push" do
+      it "appends element" do
+        expect(@gsl_wrapper.push(15)).to eq(
+          Daru::Accessors::GSLWrapper.new([1,2,3,4,5,6,15], @stub_context)
+        )
+      end
     end
   end
 end
+

data/spec/accessors/nmatrix_wrapper_spec.rb

@@ -1,32 +1,35 @@
 require 'spec_helper.rb'
 
-describe Daru::Accessors::NMatrixWrapper do
-  before :each do
-    stub_context = Object.new
-    @nm_wrapper = Daru::Accessors::NMatrixWrapper.new([1,2,3,4,5], stub_context, :float32)
-  end
+if Daru.has_nmatrix?
+  describe Daru::Accessors::NMatrixWrapper do
+    before :each do
+      stub_context = Object.new
+      @nm_wrapper = Daru::Accessors::NMatrixWrapper.new([1,2,3,4,5], stub_context, :float32)
+    end
 
-  it "checks for actual NMatrix creation" do
-    expect(@nm_wrapper.data.class).to eq(NMatrix)
-  end
+    it "checks for actual NMatrix creation" do
+      expect(@nm_wrapper.data.class).to eq(NMatrix)
+    end
 
-  it "checks the actual size of the NMatrix object" do
-    expect(@nm_wrapper.data.size).to eq(10)
-  end
+    it "checks the actual size of the NMatrix object" do
+      expect(@nm_wrapper.data.size).to eq(10)
+    end
 
-  it "checks that @size is the number of elements in the vector" do
-    expect(@nm_wrapper.size).to eq(5)
-  end
+    it "checks that @size is the number of elements in the vector" do
+      expect(@nm_wrapper.size).to eq(5)
+    end
 
-  it "checks for underlying NMatrix data type" do
-    expect(@nm_wrapper.data.dtype).to eq(:float32)
-  end
+    it "checks for underlying NMatrix data type" do
+      expect(@nm_wrapper.data.dtype).to eq(:float32)
+    end
 
-  it "resizes" do
-    @nm_wrapper.resize(100)
+    it "resizes" do
+      @nm_wrapper.resize(100)
 
-    expect(@nm_wrapper.size).to eq(5)
-    expect(@nm_wrapper.data.size).to eq(100)
-    expect(@nm_wrapper.data).to eq(NMatrix.new [100], [1,2,3,4,5])
+      expect(@nm_wrapper.size).to eq(5)
+      expect(@nm_wrapper.data.size).to eq(100)
+      expect(@nm_wrapper.data).to eq(NMatrix.new [100], [1,2,3,4,5])
+    end
   end
 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 }
@@ -1596,7 +1596,7 @@ describe Daru::DataFrame, "categorical" do
       Daru::DataFrame.new({
         a: [1, 2, 3, 4, 5],
         b: ['first', 'second', 'first', 'second', 'third'],
-        c: ['a', 'b', 'a', 'b', 'c']
+        c: ['a', 'b', 'a', 'b', nil]
       })
     end
     before { df.to_category :b, :c }
@@ -1605,6 +1605,10 @@ describe Daru::DataFrame, "categorical" do
     it { is_expected.to be_a Daru::DataFrame }
     its(:'b.type') { is_expected.to eq :category }
     its(:'c.type') { is_expected.to eq :category }
+    its(:'a.count') { is_expected.to eq 5 }
+    its(:'c.count') { is_expected.to eq 5 }
+    it { expect(df.c.count('a')).to eq 2 }
+    it { expect(df.c.count(nil)).to eq 1 }
   end
 
   context "#interact_code" do

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],
@@ -154,6 +201,22 @@ describe Daru::Core::GroupBy do
     end
   end
 
+  context '#each_group without block' do
+    it 'enumerates groups' do
+      enum = @dl_group.each_group
+
+      expect(enum.count).to eq 6
+      expect(enum).to all be_a(Daru::DataFrame)
+      expect(enum.to_a.last).to eq(Daru::DataFrame.new({
+        a: ['foo', 'foo'],
+        b: ['two', 'two'],
+        c: [3, 3],
+        d: [33, 55]
+        }, index: [2, 4]
+      ))
+    end
+  end
+
   context '#first' do
     it 'gets the first row from each group' do
       expect(@dl_group.first).to eq(Daru::DataFrame.new({
@@ -176,10 +239,6 @@ describe Daru::Core::GroupBy do
     end
   end
 
-  context "#aggregate" do
-    pending
-  end
-
   context "#mean" do
     it "computes mean of the numeric columns of a single layer group" do
       expect(@sl_group.mean).to eq(Daru::DataFrame.new({
@@ -418,4 +477,179 @@ describe Daru::Core::GroupBy do
 
     it { is_expected.to eq Daru::DataFrame.new({num: [6]}, index: ['a']) }
   end
+
+  context 'when dataframe tuples contain nils in mismatching positions' do
+
+    let(:df){
+      Daru::DataFrame.new(
+        {
+          'string1' => ["Color", "Color", "Color", "Color", nil, "Color", "Color", " Black and White"],
+          'string2' => ["Test", "test2", nil, "test3", nil, "test", "test3", "test5"],
+          'num' => [1, nil, 3, 4, 5, 6, 7, nil]
+        }
+      )
+    }
+
+    it 'groups by without errors' do
+      expect { df.group_by(df.vectors.map(&:to_s)) }.to_not raise_error(ArgumentError)
+    end
+  end
+  
+  context '#aggregate' do
+    let(:dataframe) { 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]})
+    }
+    context 'group and aggregate sum for particular single vector' do
+      subject { dataframe.group_by([:employee]).aggregate(salary: :sum) }
+
+      it { is_expected.to eq Daru::DataFrame.new({
+              salary: [1100, 2200, 1300]},
+              index: ['Jane', 'John', 'Mark'])
+      }
+    end
+
+    context 'group and aggregate sum and lambda function for vectors' do
+      subject { dataframe.group_by([:employee]).aggregate(
+        salary: :sum,
+        month: ->(vec) { vec.to_a.join('/') }) }
+
+      it { is_expected.to eq Daru::DataFrame.new({
+        salary: [1100, 2200, 1300],
+        month: ['June/July', 'June/July', 'June/July']},
+        index: ['Jane', 'John', 'Mark'],
+        order: [:salary, :month])
+      }
+    end
+
+    context 'group and aggregate sum and lambda functions on dataframe' do
+      subject { dataframe.group_by([:employee]).aggregate(
+        salary: :sum,
+        month: ->(vec) { vec.to_a.join('/') },
+        mean_salary: ->(df) { df.salary.mean },
+        periods: ->(df) { df.size }
+      )}
+
+      it { is_expected.to eq Daru::DataFrame.new({
+        salary: [1100, 2200, 1300],
+        month: ['June/July', 'June/July', 'June/July'],
+        mean_salary: [550.0, 1100.0, 650.0],
+        periods: [2, 2, 2]},
+        index: ['Jane', 'John', 'Mark'], order: [:salary, :month,
+                                                :mean_salary, :periods]) }
+    end
+
+    context 'group_by and aggregate on mixed MultiIndex' do
+      let(:df) { Daru::DataFrame.new(
+                    name: ['Ram','Krishna','Ram','Krishna','Krishna'],
+                    visited: [
+                      'Hyderabad', 'Delhi', 'Mumbai', 'Raipur', 'Banglore']
+                 )
+                }
+      let(:df_mixed) { Daru::DataFrame.new(
+                    name: ['Krishna','Ram','Krishna','Krishna'],
+                    visited: [
+                      'Delhi', 'Mumbai', 'Raipur', 'Banglore']
+                 )
+                }
+      it 'group_by' do
+        expect(df.group_by(:name).df).to eq(
+          Daru::DataFrame.new({
+            visited: ['Delhi', 'Raipur', 'Banglore', 'Hyderabad', 'Mumbai']},
+            index: Daru::MultiIndex.from_tuples(
+                [['Krishna', 1], ['Krishna', 3], ['Krishna', 4],
+                ['Ram', 0], ['Ram', 2]]
+            )
+          )
+        )
+      end
+
+      it 'group_by and aggregate' do
+        expect(
+          df.group_by(:name).aggregate(
+            visited: -> (vec){vec.to_a.join(',')})).to eq(
+              Daru::DataFrame.new({
+                visited: ['Delhi,Raipur,Banglore', 'Hyderabad,Mumbai']},
+                index: ['Krishna', 'Ram']
+              )
+          )
+      end
+
+      it 'group_by and aggregate when anyone index is not multiple times' do
+        expect(
+          df_mixed.group_by(:name).aggregate(
+            visited: -> (vec){vec.to_a.join(',')})).to eq(
+              Daru::DataFrame.new({
+                visited: ['Delhi,Raipur,Banglore', 'Mumbai']},
+                index: ['Krishna', 'Ram']
+              )
+          )
+      end
+    end
+
+    let(:spending_df) {
+      Daru::DataFrame.rows([
+        [2010,    'dev',  50, 1],
+        [2010,    'dev', 150, 1],
+        [2010,    'dev', 200, 1],
+        [2011,    'dev',  50, 1],
+        [2012,    'dev', 150, 1],
+
+        [2011, 'office', 300, 1],
+
+        [2010, 'market',  50, 1],
+        [2011, 'market', 500, 1],
+        [2012, 'market', 500, 1],
+        [2012, 'market', 300, 1],
+
+        [2012,    'R&D',  10, 1],],
+        order: [:year, :category, :spending, :nb_spending])
+    }
+    let(:multi_index_year_category) {
+      Daru::MultiIndex.from_tuples([
+                       [2010, "dev"], [2010, "market"],
+                       [2011, "dev"], [2011, "market"], [2011, "office"],
+        [2012, "R&D"], [2012, "dev"], [2012, "market"]])
+    }
+
+    context 'group_by and aggregate on multiple elements' do
+      it 'does aggregate' do
+        expect(spending_df.group_by([:year, :category]).aggregate(spending: :sum)).to eq(
+          Daru::DataFrame.new({spending: [400, 50, 50, 500, 300, 10, 150, 800]}, index: multi_index_year_category))
+      end
+
+      it 'works as older methods' do
+        older_way = spending_df.group_by([:year, :category]).sum
+
+        newer_way = spending_df.group_by([:year, :category]).aggregate(spending: :sum, nb_spending: :sum)
+        expect(newer_way).to eq(older_way)
+
+        contrived_way = spending_df.group_by([:year, :category]).aggregate(spending: :sum, nb_spending_lambda: ->(df) { df[:nb_spending].sum })
+        contrived_way.rename_vectors(nb_spending_lambda: :nb_spending)
+        expect(contrived_way).to eq(older_way)
+      end
+
+      context 'can aggregate on MultiIndex' do
+        let(:multi_indexed_aggregated_df) { spending_df.group_by([:year, :category]).aggregate(spending: :sum) }
+        let(:index_year) { Daru::Index.new([2010, 2011, 2012]) }
+        let(:index_category) { Daru::Index.new(["dev", "market", "office", "R&D"]) }
+
+        it 'aggregates by default on the last layer of MultiIndex' do
+          expect(multi_indexed_aggregated_df.aggregate(spending: :sum)).to eq(
+            Daru::DataFrame.new({spending: [450, 850, 960]}, index: index_year))
+        end
+
+        it 'can aggregate on the first layer of MultiIndex' do
+          expect(multi_indexed_aggregated_df.aggregate({spending: :sum},0)).to eq(
+            Daru::DataFrame.new({spending: [600, 1350, 300, 10]}, index: index_category))
+        end
+
+        it 'does coercion: when one layer is remaining, MultiIndex is coerced in Index that does not aggregate anymore' do
+          df_with_simple_index = multi_indexed_aggregated_df.aggregate(spending: :sum)
+          expect(df_with_simple_index.aggregate(spending: :sum)).to eq(df_with_simple_index)
+        end
+      end
+    end
+  end
 end