daru 0.1.3.1 → 0.1.4

data/spec/io/io_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper.rb'
-
 describe Daru::IO do
   describe Daru::DataFrame do
     context ".from_csv" do
@@ -29,7 +27,7 @@ describe Daru::IO do
           expect(y_ds).to be_within(0.001).of(y_expected)
         end
       end
-      
+
       it "follows the order of columns given in CSV" do
         df = Daru::DataFrame.from_csv 'spec/fixtures/sales-funnel.csv'
         expect(df.vectors.to_a).to eq(%W[Account Name Rep Manager Product Quantity Price Status])
@@ -145,8 +143,23 @@ describe Daru::IO do
     end
 
     context "#write_sql" do
+      let(:df) { Daru::DataFrame.new({
+          'a' => [1,2,3,4,5],
+          'b' => [11,22,33,44,55],
+          'c' => ['a', 'g', 4, 5,'addadf'],
+          'd' => [nil, 23, 4,'a','ff']})
+      }
+
+      let(:dbh) { double }
+      let(:prepared_query) { double }
+
       it "writes the DataFrame to an SQL database" do
-        # TODO: write these tests
+        expect(dbh).to receive(:prepare)
+          .with('INSERT INTO tbl (a,b,c,d) VALUES (?,?,?,?)')
+          .and_return(prepared_query)
+        df.each_row { |r| expect(prepared_query).to receive(:execute).with(*r.to_a).ordered }
+
+        df.write_sql dbh, 'tbl'
       end
     end
 
@@ -201,6 +214,20 @@ describe Daru::IO do
 
         expect(df.vectors.to_a).to eq([:v1,:v2,:v3,:v4,:v5,:v6])
       end
+
+      xit "understands empty fields" do
+        pending 'See FIXME note in io.rb'
+
+        df = Daru::DataFrame.from_plaintext 'spec/fixtures/empties.dat', [:v1,:v2,:v3]
+
+        expect(df.row[1].to_a).to eq [4, nil, 6]
+      end
+
+      it "understands non-numeric fields" do
+        df = Daru::DataFrame.from_plaintext 'spec/fixtures/strings.dat', [:v1,:v2,:v3]
+
+        expect(df[:v1].to_a).to eq ['test', 'foo']
+      end
     end
 
     context "JSON" do

data/spec/io/sql_data_source_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'daru/io/sql_data_source'
 require 'sqlite3'
 require 'dbi'

data/spec/iruby/dataframe_spec.rb

@@ -0,0 +1,172 @@
+describe Daru::DataFrame, '#to_html' do
+  let(:doc) { Nokogiri::HTML(df.to_html) }
+  subject(:table) { doc.at('table') }
+  let(:header) { table.at('tr:first-child > th:first-child') }
+  let(:name) { 'test' }
+
+  let(:splitted_row) { row.inner_html.scan(/<t[dh].+?<\/t[dh]>/) }
+
+  context 'simple' do
+    let(:df) { Daru::DataFrame.new({a: [1,2,3], b: [3,4,5], c: [6,7,8]}, name: name)}
+
+    describe 'header' do
+      subject { header }
+
+      it { is_expected.not_to be_nil }
+      its(['colspan']) { is_expected.to eq (df.ncols + 1).to_s }
+      its(:text) { is_expected.to eq "Daru::DataFrame: test (3x3)" }
+
+      context 'without name' do
+        let(:name) { nil }
+
+        its(:text) { is_expected.to eq "Daru::DataFrame(3x3)" }
+      end
+    end
+
+    describe 'column headers' do
+      subject(:columns) { table.search('tr:nth-child(2) th').map(&:text) }
+      its(:size) { is_expected.to eq df.ncols + 1 }
+      it { is_expected.to eq ['', 'a', 'b', 'c'] }
+    end
+
+    context 'with multi-index columns' do
+      before { df.vectors = Daru::MultiIndex.from_tuples [[:a, :foo], [:a, :baz], [:b, :foo]] }
+
+      subject { splitted_row }
+      describe 'first row' do
+        let(:row) { table.search('tr:nth-child(2)') }
+
+        it { is_expected.to eq [
+          '<th rowspan="2"></th>',
+          '<th colspan="2">a</th>',
+          '<th colspan="1">b</th>'
+        ] }
+      end
+
+      describe 'next row' do
+        let(:row) { table.search('tr:nth-child(3)') }
+
+        it { is_expected.to eq [
+          '<th colspan="1">foo</th>',
+          '<th colspan="1">baz</th>',
+          '<th colspan="1">foo</th>'
+        ] }
+      end
+    end
+
+    describe 'index' do
+      subject(:indexes) { table.search('tr > td:first-child').map(&:text) }
+      its(:count) { is_expected.to eq df.nrows }
+      it { is_expected.to eq df.index.to_a.map(&:to_s) }
+    end
+
+    describe 'values' do
+      subject(:values) {
+        table.search('tr')[2..-1]
+             .map { |tr| tr.search('td')[1..-1].map(&:text) }
+      }
+      its(:count) { is_expected.to eq df.nrows }
+      it { is_expected.to eq df.map_rows{|r| r.map(&:to_s)} }
+    end
+  end
+
+  context 'large dataframe' do
+    let(:df) { Daru::DataFrame.new({a: [1,2,3]*100, b: [3,4,5]*100, c: [6,7,8]*100}, name: 'test') }
+
+    describe 'header' do
+      subject { header }
+
+      its(:text) { is_expected.to eq "Daru::DataFrame: test (300x3)" }
+    end
+
+    it 'has only 30 rows (+ 2 header rows, + 2 finishing rows)' do
+      expect(table.search('tr').size).to eq 34
+    end
+
+    describe '"skipped" row' do
+      subject(:row) { table.search('tr:nth-child(33) td').map(&:text) }
+      its(:count) { is_expected.to eq df.ncols + 1 }
+      it { is_expected.to all eq '...' }
+    end
+
+    describe 'last row' do
+      subject(:row) { table.search('tr:nth-child(34) td').map(&:text) }
+      its(:count) { is_expected.to eq df.ncols + 1 }
+      it { is_expected.to eq ['299', *df.row[-1].map(&:to_s)] }
+    end
+  end
+
+  context 'with multi-index' do
+    let(:df) {
+      Daru::DataFrame.new(
+        {
+          a:   [1,2,3,4,5,6,7],
+          b: %w[a b c d e f g]
+        }, index: Daru::MultiIndex.from_tuples([
+              %w[foo one],
+              %w[foo two],
+              %w[foo three],
+              %w[bar one],
+              %w[bar two],
+              %w[bar three],
+              %w[baz one],
+           ]),
+           name: 'test'
+      )
+    }
+
+    describe 'header' do
+      subject { header }
+
+      it { is_expected.not_to be_nil }
+      its(['colspan']) { is_expected.to eq (df.ncols + df.index.width).to_s }
+      its(:text) { is_expected.to eq "Daru::DataFrame: test (7x2)" }
+    end
+
+    describe 'column headers' do
+      let(:row) { table.search('tr:nth-child(2)') }
+      subject { splitted_row }
+
+      it { is_expected.to eq [
+        '<th colspan="2"></th>',
+        '<th>a</th>',
+        '<th>b</th>'
+      ]}
+    end
+
+    context 'with multi-index columns' do
+      before { df.vectors = Daru::MultiIndex.from_tuples [[:a, :foo], [:a, :baz]] }
+
+      subject { splitted_row }
+      describe 'first row' do
+        let(:row) { table.search('tr:nth-child(2)') }
+
+        it { is_expected.to eq [
+          '<th colspan="2" rowspan="2"></th>',
+          '<th colspan="2">a</th>',
+        ] }
+      end
+
+      describe 'next row' do
+        let(:row) { table.search('tr:nth-child(3)') }
+
+        it { is_expected.to eq [
+          '<th colspan="1">foo</th>',
+          '<th colspan="1">baz</th>',
+        ] }
+      end
+    end
+
+    describe 'first row' do
+      let(:row) { table.search('tr:nth-child(3)') }
+      subject { splitted_row }
+
+      it { is_expected.to eq [
+        '<th rowspan="3">foo</th>',
+        '<th rowspan="1">one</th>',
+        '<td>1</td>',
+        '<td>a</td>'
+      ]}
+    end
+  end
+end

data/spec/iruby/helpers_spec.rb

@@ -0,0 +1,49 @@
+describe Daru::IRuby::Helpers do
+  context 'MultiIndex' do
+    let(: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],
+        [:c,:one,:bar],
+        [:c,:one,:baz],
+        [:c,:two,:foo],
+        [:c,:two,:bar]
+      ]
+    }
+
+    context '#tuples_with_rowspans' do
+      subject { described_class.tuples_with_rowspans(index) }
+
+      it { is_expected.to eq [
+          [[:a,4],[:one,2],[:bar,1]],
+          [                [:baz,1]],
+          [       [:two,2],[:bar,1]],
+          [                [:baz,1]],
+          [[:b,4],[:one,1],[:bar,1]],
+          [       [:two,2],[:bar,1]],
+          [                [:baz,1]],
+          [       [:one,1],[:foo,1]],
+          [[:c,4],[:one,2],[:bar,1]],
+          [                [:baz,1]],
+          [       [:two,2],[:foo,1]],
+          [                [:bar,1]]
+      ]}
+    end
+
+    context '#tuples_with_colspans' do
+      subject { described_class.tuples_with_colspans(index) }
+
+      it { is_expected.to eq [
+          [[:a, 4], [:b, 4], [:c, 4]],
+          [[:one, 2], [:two, 2], [:one, 1], [:two, 2], [:one, 1], [:one, 2], [:two, 2]],
+          [[:bar, 1], [:baz, 1], [:bar, 1], [:baz, 1], [:bar, 1], [:bar, 1], [:baz, 1], [:foo, 1], [:bar, 1], [:baz, 1], [:foo, 1], [:bar, 1]]
+      ]}
+    end
+  end
+end

data/spec/iruby/multi_index_spec.rb

@@ -0,0 +1,37 @@
+describe Daru::MultiIndex, '#to_html' do
+  let(: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],
+      [:c,:one,:bar],
+      [:c,:one,:baz],
+      [:c,:two,:foo],
+      [:c,:two,:bar]
+    ]
+  }
+
+  let(:table) { Nokogiri::HTML(index.to_html) }
+
+  describe 'first row' do
+    subject { table.at('tr:first-child > th') }
+    its(['colspan']) { is_expected.to eq '3' }
+    its(:text) { is_expected.to eq 'Daru::MultiIndex(12x3)' }
+  end
+
+  describe 'next row' do
+    let(:row) { table.at('tr:nth-child(2)') }
+    subject { row.inner_html.scan(/<th.+?<\/th>/) }
+
+    it { is_expected.to eq [
+        '<th rowspan="4">a</th>',
+        '<th rowspan="2">one</th>',
+        '<th rowspan="1">bar</th>'
+    ]}
+  end
+end

data/spec/iruby/vector_spec.rb

@@ -0,0 +1,107 @@
+describe Daru::Vector, '#to_html' do
+  [nil, :category].each do |type|
+    let(:doc) { Nokogiri::HTML(vector.to_html) }
+    subject(:table) { doc.at('table') }
+    let(:header) { table.at('tr:first-child > th:first-child') }
+  
+    context 'simple' do
+      let(:vector) { Daru::Vector.new [1,nil,3],
+        index: [:a, :b, :c], name: 'test', type: type }
+      it { is_expected.not_to be_nil }
+  
+      describe 'header' do
+        subject { header }
+        it { is_expected.not_to be_nil }
+        its(['colspan']) { is_expected.to eq '2' }
+        its(:text) { is_expected.to eq "Daru::Vector(3)"\
+          "#{":category" if type == :category}" }
+      end
+  
+      describe 'name' do
+        subject(:name) { table.at('tr:nth-child(2) > th:nth-child(2)') }
+        it { is_expected.not_to be_nil }
+        its(:text) { is_expected.to eq 'test' }
+  
+        context 'withought name' do
+          let(:vector) { Daru::Vector.new [1,nil,3], index: [:a, :b, :c], type: type }
+  
+          it { is_expected.to be_nil }
+        end
+      end
+  
+      describe 'index' do
+        subject(:indexes) { table.search('tr > td:first-child').map(&:text) }
+        its(:count) { is_expected.to eq vector.size }
+        it { is_expected.to eq vector.index.to_a.map(&:to_s) }
+      end
+  
+      describe 'values' do
+        subject(:indexes) { table.search('tr > td:last-child').map(&:text) }
+        its(:count) { is_expected.to eq vector.size }
+        it { is_expected.to eq vector.to_a.map(&:to_s) }
+      end
+    end
+  
+    context 'large vector' do
+      subject(:vector) { Daru::Vector.new [1,2,3] * 100, name: 'test', type: type }
+      it 'has only 30 rows (+ 2 header rows, + 2 finishing rows)' do
+        expect(table.search('tr').size).to eq 34
+      end
+  
+      describe '"skipped" row' do
+        subject(:row) { table.search('tr:nth-child(33) td').map(&:text) }
+        its(:count) { is_expected.to eq 2 }
+        it { is_expected.to eq ['...', '...'] }
+      end
+  
+      describe 'last row' do
+        subject(:row) { table.search('tr:nth-child(34) td').map(&:text) }
+        its(:count) { is_expected.to eq 2 }
+        it { is_expected.to eq ['299', '3'] }
+      end
+    end
+  
+    context 'multi-index' do
+      subject(:vector) {
+        Daru::Vector.new(
+          [1,2,3,4,5,6,7],
+          name: 'test',
+          type: type,
+          index: Daru::MultiIndex.from_tuples([
+              %w[foo one],
+              %w[foo two],
+              %w[foo three],
+              %w[bar one],
+              %w[bar two],
+              %w[bar three],
+              %w[baz one],
+           ]),
+        )
+      }
+  
+      describe 'header' do
+        subject { header }
+        it { is_expected.not_to be_nil }
+        its(['colspan']) { is_expected.to eq '3' }
+        its(:text) { is_expected.to eq "Daru::Vector(7)"\
+          "#{":category" if type == :category}" }
+      end
+  
+      describe 'name row' do
+        subject(:row) { table.at('tr:nth-child(2)').search('th') }
+        its(:count) { should == 2 }
+        it { expect(row.first['colspan']).to eq '2' }
+      end
+  
+      describe 'first data row' do
+        let(:row) { table.at('tr:nth-child(3)') }
+        subject { row.inner_html.scan(/<t[dh].+?<\/t[dh]>/) }
+        it { is_expected.to eq [
+          '<th rowspan="3">foo</th>',
+          '<th rowspan="1">one</th>',
+          '<td>1</td>'
+        ]}
+      end
+    end
+  end
+end

data/spec/math/arithmetic/dataframe_spec.rb

@@ -1,25 +1,23 @@
-require 'spec_helper.rb'
-
 describe Daru::DataFrame do
   before(:each) do
-    @df = Daru::DataFrame.new({a: [1,2,3,4,5], b: ['a','e','i','o','u'], 
+    @df = Daru::DataFrame.new({a: [1,2,3,4,5], b: ['a','e','i','o','u'],
       c: [10,20,30,40,50]})
     @left = Daru::DataFrame.new({a: [1,nil,nil,4], b: [10,nil,nil,40], c: [5,6,7,8]},
       index: [0,4,5,3])
-    @right = Daru::DataFrame.new({a: [1,2,3,4,5], b: [10,20,30,40,50]}, 
+    @right = Daru::DataFrame.new({a: [1,2,3,4,5], b: [10,20,30,40,50]},
       index: [0,1,2,3,6])
   end
 
   context "#+" do
     it "adds a number to all numeric vectors" do
-      expect(@df + 2).to eq(Daru::DataFrame.new({a: [3,4,5,6,7], b: ['a','e','i','o','u'], 
+      expect(@df + 2).to eq(Daru::DataFrame.new({a: [3,4,5,6,7], b: ['a','e','i','o','u'],
       c: [12,22,32,42,52] }))
     end
 
     it "adds two dataframes to produce a third" do
       expect(@left + @right).to eq(Daru::DataFrame.new({
         a: [2,nil,nil,8,nil,nil],
-        b: [20,nil,nil,80,nil,nil], 
+        b: [20,nil,nil,80,nil,nil],
         c: [nil,nil,nil,nil,nil,nil]
         }, index: [0,1,2,3,4,5,6]))
     end
@@ -28,36 +26,85 @@ describe Daru::DataFrame do
   context "#-" do
     it "subtracts a number from all numeric vectors" do
       expect(@df - 2).to eq(Daru::DataFrame.new({
-        a: [-1,0,1,2,3], 
-        b: ['a','e','i','o','u'], 
+        a: [-1,0,1,2,3],
+        b: ['a','e','i','o','u'],
         c: [8,18,28,38,48]}))
     end
 
     it "subtracts a data frame from another" do
-
+      expect(@left - @right).to eq(Daru::DataFrame.new({
+        a: [0,nil,nil,0,nil,nil],
+        b: [0,nil,nil,0,nil,nil],
+        c: [nil,nil,nil,nil,nil,nil]
+        }, index: [0,1,2,3,4,5,6]))
     end
   end
 
   context "#*" do
-    it "multiplies a number with a DataFrame" do
+    it "multiplies all numeric vectors by number" do
+      expect(@df * 2).to eq(Daru::DataFrame.new({a: [2,4,6,8,10], b: ['a','e','i','o','u'],
+      c: [20,40,60,80,100] }))
+    end
+
+    it "multipies two dataframes to produce a third" do
+      expect(@left * @right).to eq(Daru::DataFrame.new({
+        a: [1,nil,nil,16,nil,nil],
+        b: [100,nil,nil,1600,nil,nil],
+        c: [nil,nil,nil,nil,nil,nil]
+        }, index: [0,1,2,3,4,5,6]))
     end
   end
 
   context "#/" do
+    it "divides all numeric vectors by number" do
+      expect(@df / 2.0).to eq(Daru::DataFrame.new({a: [0.5, 1, 1.5, 2, 2.5], b: ['a','e','i','o','u'],
+      c: [5,10,15,20,25] }))
+    end
 
+    it "multipies two dataframes to produce a third" do
+      # NB: this and other tests of two DF interactions are not EXTREMELY
+      # useful, but to know that nothing unexpected emerges here
+      expect(@left / @right).to eq(Daru::DataFrame.new({
+        a: [1,nil,nil,1,nil,nil],
+        b: [1,nil,nil,1,nil,nil],
+        c: [nil,nil,nil,nil,nil,nil]
+        }, index: [0,1,2,3,4,5,6]))
+    end
   end
 
   context "#%" do
+    it "divides all numeric vectors by number and returns reminder" do
+      expect(@df % 3).to eq(Daru::DataFrame.new({a: [1, 2, 0, 1, 2], b: ['a','e','i','o','u'],
+      c: [1, 2, 0, 1, 2] }))
+    end
 
+    it "returns reminder of per-item division" do
+      expect(@left % @right).to eq(Daru::DataFrame.new({
+        a: [0,nil,nil,0,nil,nil],
+        b: [0,nil,nil,0,nil,nil],
+        c: [nil,nil,nil,nil,nil,nil]
+        }, index: [0,1,2,3,4,5,6]))
+    end
   end
 
   context "#**" do
+    it "calculates result of each numeric value pow" do
+      expect(@df ** 2).to eq(Daru::DataFrame.new({a: [1, 4, 9, 16, 25], b: ['a','e','i','o','u'],
+      c: [100, 400, 900, 1600, 2500] }))
+    end
 
+    it "returns per-item pow" do
+      expect(@left ** @right).to eq(Daru::DataFrame.new({
+        a: [1,nil,nil,4**4,nil,nil],
+        b: [10**10,nil,nil,40**40,nil,nil],
+        c: [nil,nil,nil,nil,nil,nil]
+        }, index: [0,1,2,3,4,5,6]))
+    end
   end
 
   context "#sqrt" do
     it "calculates sqrt" do
-      expect_correct_df_in_delta(@df.sqrt, 
+      expect_correct_df_in_delta(@df.sqrt,
         Daru::DataFrame.new({
           a: [1.0,1.41421356,1.73205080,2.0,2.23606797],
           c: [3.16227766, 4.47213595 ,5.47722557 ,6.32455532, 7.07106781]
@@ -84,7 +131,18 @@ describe Daru::DataFrame do
 
   context "#exp" do
     it "calculates exponential" do
-      @df.exp
+      e = Math::E
+      df = Daru::DataFrame.new({
+        a: [1,2,3],
+        b: [4,5,6],
+        c: %w(a b c)
+      })
+      ans = Daru::DataFrame.new({
+        a: [e, e**2, e**3],
+        b: [e**4, e**5, e**6],
+      })
+
+      expect_correct_df_in_delta(df.exp, ans, 0.0001)
     end
   end
-end
+end