daru 0.1.5 → 0.1.6

data/spec/io/sql_data_source_spec.rb

@@ -5,62 +5,52 @@ require 'active_record'
 
 RSpec.describe Daru::IO::SqlDataSource do
   include_context 'with accounts table in sqlite3 database'
-  let(:dbi_handle) do
-    DBI.connect("DBI:SQLite3:#{db_name}")
+
+  let(:query) do
+    'select * from accounts'
   end
 
-  let(:active_record_connection) do
+  let(:source) do
     ActiveRecord::Base.establish_connection("sqlite3:#{db_name}")
     ActiveRecord::Base.connection
   end
 
-  let(:query) do
-    'select * from accounts'
-  end
-
   describe '.make_dataframe' do
-    context 'with DBI::DatabaseHandle' do
-      it 'returns a dataframe' do
-        result = Daru::IO::SqlDataSource.make_dataframe(dbi_handle, query)
-        expect(result).to be_a(Daru::DataFrame)
-        expect(result.nrows).to eq(2)
-        expect(result.row[0][:id]).to eq(1)
-        expect(result.row[0][:name]).to eq('Homer')
-      end
+    subject(:df) { Daru::IO::SqlDataSource.make_dataframe(source, query) }
 
-      context 'with an object not a string as a query' do
-        it 'raises ArgumentError' do
-          expect {
-            Daru::IO::SqlDataSource.make_dataframe(dbi_handle, Object.new)
-          }.to raise_error(ArgumentError)
-        end
-      end
+    context 'with DBI::DatabaseHandle' do
+      let(:source) { DBI.connect("DBI:SQLite3:#{db_name}") }
+      it { is_expected.to be_a(Daru::DataFrame) }
+      it { expect(df.row[0]).to have_attributes(id: 1, age: 20) }
+      its(:nrows) { is_expected.to eq 2 }
     end
 
     context 'with ActiveRecord::Connection' do
-      it 'returns a dataframe' do
-        result = Daru::IO::SqlDataSource.make_dataframe(active_record_connection, query)
-        expect(result).to be_a(Daru::DataFrame)
-        expect(result.nrows).to eq(2)
-        expect(result.row[0][:id]).to eq(1)
-        expect(result.row[0][:name]).to eq('Homer')
-      end
+      it { is_expected.to be_a(Daru::DataFrame) }
+      it { expect(df.row[0]).to have_attributes(id: 1, age: 20) }
+      its(:nrows) { is_expected.to eq 2 }
+    end
 
-      context 'with an object not a string as a query' do
-        it 'raises ArgumentError' do
-          expect {
-            Daru::IO::SqlDataSource.make_dataframe(active_record_connection, Object.new)
-          }.to raise_error(ArgumentError)
-        end
-      end
+    context 'with path to sqlite3 file' do
+      let(:source) { db_name }
+      it { is_expected.to be_a(Daru::DataFrame) }
+      it { expect(df.row[0]).to have_attributes(id: 1, age: 20) }
+      its(:nrows) { is_expected.to eq 2 }
+    end
+
+    context 'with an object not a string as a query' do
+      let(:query) { Object.new }
+      it { expect { df }.to raise_error(ArgumentError) }
     end
 
     context 'with an object not a database connection' do
-      it 'raises ArgumentError' do
-        expect {
-          Daru::IO::SqlDataSource.make_dataframe(Object.new, query)
-        }.to raise_error(ArgumentError)
-      end
+      let(:source) { Object.new }
+      it { expect { df }.to raise_error(ArgumentError) }
+    end
+
+    context 'with path to unsupported db file' do
+      let(:source) { 'spec/fixtures/bank2.dat' }
+      it { expect { df }.to raise_error(ArgumentError) }
     end
   end
 end

data/spec/iruby/dataframe_spec.rb

@@ -1,7 +1,7 @@
 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(:header) { doc.at('b')}
   let(:name) { 'test' }
 
   let(:splitted_row) { row.inner_html.scan(/<t[dh].+?<\/t[dh]>/) }
@@ -13,18 +13,17 @@ describe Daru::DataFrame, '#to_html' 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)" }
+      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)" }
+        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) }
+      subject(:columns) { table.search('tr:nth-child(1) th').map(&:text) }
       its(:size) { is_expected.to eq df.ncols + 1 }
       it { is_expected.to eq ['', 'a', 'b', 'c'] }
     end
@@ -34,7 +33,7 @@ describe Daru::DataFrame, '#to_html' do
 
       subject { splitted_row }
       describe 'first row' do
-        let(:row) { table.search('tr:nth-child(2)') }
+        let(:row) { table.search('thead > tr:nth-child(1)') }
 
         it { is_expected.to eq [
           '<th rowspan="2"></th>',
@@ -44,7 +43,7 @@ describe Daru::DataFrame, '#to_html' do
       end
 
       describe 'next row' do
-        let(:row) { table.search('tr:nth-child(3)') }
+        let(:row) { table.search('thead > tr:nth-child(2)') }
 
         it { is_expected.to eq [
           '<th colspan="1">foo</th>',
@@ -62,7 +61,7 @@ describe Daru::DataFrame, '#to_html' do
 
     describe 'values' do
       subject(:values) {
-        table.search('tr')[2..-1]
+        table.search('tr')[1..-1]
              .map { |tr| tr.search('td')[1..-1].map(&:text) }
       }
       its(:count) { is_expected.to eq df.nrows }
@@ -76,21 +75,21 @@ describe Daru::DataFrame, '#to_html' do
     describe 'header' do
       subject { header }
 
-      its(:text) { is_expected.to eq "Daru::DataFrame: test (300x3)" }
+      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
+    it 'has only 30 rows (+ 1 header rows, + 2 finishing rows)' do
+      expect(table.search('tr').size).to eq 33
     end
 
     describe '"skipped" row' do
-      subject(:row) { table.search('tr:nth-child(33) td').map(&:text) }
+      subject(:row) { table.search('tr:nth-child(31) 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) }
+      subject(:row) { table.search('tr:nth-child(32) 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
@@ -119,12 +118,11 @@ describe Daru::DataFrame, '#to_html' 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)" }
+      its(:text) { is_expected.to eq " Daru::DataFrame: test (7x2) " }
     end
 
     describe 'column headers' do
-      let(:row) { table.search('tr:nth-child(2)') }
+      let(:row) { table.search('thead > tr:nth-child(1)') }
       subject { splitted_row }
 
       it { is_expected.to eq [
@@ -139,7 +137,7 @@ describe Daru::DataFrame, '#to_html' do
 
       subject { splitted_row }
       describe 'first row' do
-        let(:row) { table.search('tr:nth-child(2)') }
+        let(:row) { table.search('thead > tr:nth-child(1)') }
 
         it { is_expected.to eq [
           '<th colspan="2" rowspan="2"></th>',
@@ -148,7 +146,7 @@ describe Daru::DataFrame, '#to_html' do
       end
 
       describe 'next row' do
-        let(:row) { table.search('tr:nth-child(3)') }
+        let(:row) { table.search('thead > tr:nth-child(2)') }
 
         it { is_expected.to eq [
           '<th colspan="1">foo</th>',
@@ -158,7 +156,7 @@ describe Daru::DataFrame, '#to_html' do
     end
 
     describe 'first row' do
-      let(:row) { table.search('tr:nth-child(3)') }
+      let(:row) { table.search('tbody > tr:nth-child(1)') }
       subject { splitted_row }
 
       it { is_expected.to eq [

data/spec/iruby/vector_spec.rb

@@ -2,65 +2,64 @@ 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') }
-  
+    let(:header) { doc.at('b') }
+
     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}" }
+        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)') }
+        subject(:name) { table.at('tr:nth-child(1) > 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
+      it 'has only 30 rows (+ 1 header rows, + 2 finishing rows)' do
+        expect(table.search('tr').size).to eq 33
       end
-  
+
       describe '"skipped" row' do
-        subject(:row) { table.search('tr:nth-child(33) td').map(&:text) }
+        subject(:row) { table.search('tr:nth-child(31) 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) }
+        subject(:row) { table.search('tr:nth-child(32) 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(
@@ -78,23 +77,22 @@ describe Daru::Vector, '#to_html' do
            ]),
         )
       }
-  
+
       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}" }
+        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') }
+        subject(:row) { table.at('tr:nth-child(1)').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)') }
+        let(:row) { table.at('tbody > tr:first-child') }
         subject { row.inner_html.scan(/<t[dh].+?<\/t[dh]>/) }
         it { is_expected.to eq [
           '<th rowspan="3">foo</th>',

data/spec/maths/statistics/vector_spec.rb

@@ -12,6 +12,116 @@ describe Daru::Vector do
         end
       end
 
+      let(:dv) { dv = Daru::Vector.new (["Tyrion", "Daenerys", "Jon Starkgaryen"]), index: Daru::Index.new([:t, :d, :j]) }
+
+      context "#max" do
+        it "returns max value" do
+          expect(dv.max).to eq("Tyrion")
+        end
+        it "returns N max values" do
+          expect(dv.max(2)).to eq(["Tyrion","Jon Starkgaryen"])
+        end
+        it "returns max value, sorted by comparitive block input" do
+          expect(dv.max { |a,b| a.size <=> b.size }).to eq("Jon Starkgaryen")
+        end
+        it "returns max value, sorted by object block input" do
+          expect(dv.max { |x| x.size }).to eq("Jon Starkgaryen")
+        end
+        it "returns N max values, sorted by comparitive block input" do
+          expect(dv.max(2) {|a,b| a.size <=> b.size}).to eq(["Jon Starkgaryen","Daenerys"])
+        end
+        it "returns N max values, sorted by object block input" do
+          expect(dv.max(2) {|x| x.size }).to eq(["Jon Starkgaryen","Daenerys"])
+        end
+      end
+
+      context "#index_of_max" do
+        it "returns index_of_max value" do
+          expect(dv.index_of_max).to eq(:t)
+        end
+        it "returns N index_of_max values" do
+          expect(dv.index_of_max(2)).to eq([:t, :j])
+        end
+        it "returns index_of_max value, sorted by comparitive block input" do
+          expect(dv.index_of_max { |a,b| a.size <=> b.size }).to eq(:j)
+        end
+        it "returns index_of_max value, sorted by object block input" do
+          expect(dv.index_of_max { |x| x.size }).to eq(:j)
+        end
+        it "returns N index_of_max values, sorted by comparitive block input" do
+          expect(dv.index_of_max(2) {|a,b| a.size <=> b.size}).to eq([:j, :d])
+        end
+        it "returns N index_of_max values, sorted by object block input" do
+          expect(dv.index_of_max(2) {|x| x.size }).to eq([:j, :d])
+        end
+      end
+
+      context "#min" do
+        it "returns min value" do
+          expect(dv.min).to eq("Daenerys")
+        end
+        it "returns N min values" do
+          expect(dv.min(2)).to eq(["Daenerys","Jon Starkgaryen"])
+        end
+        it "returns min value, sorted by comparitive block input" do
+          expect(dv.min { |a,b| a.size <=> b.size }).to eq("Tyrion")
+        end
+        it "returns min value, sorted by object block input" do
+          expect(dv.min { |x| x.size }).to eq("Tyrion")
+        end
+        it "returns N min values, sorted by comparitive block input" do
+          expect(dv.min(2) {|a,b| a.size <=> b.size}).to eq(["Tyrion","Daenerys"])
+        end
+        it "returns N min values, sorted by object block input" do
+          expect(dv.min(2) {|x| x.size }).to eq(["Tyrion","Daenerys"])
+        end
+      end
+
+      context "#index_of_min" do
+        it "returns index of min value" do
+          expect(dv.index_of_min).to eq(:d)
+        end
+        it "returns N index of min values" do
+          expect(dv.index_of_min(2)).to eq([:d, :j])
+        end
+        it "returns index of min value, sorted by comparitive block input" do
+          expect(dv.index_of_min { |a,b| a.size <=> b.size }).to eq(:t)
+        end
+        it "returns index of min value, sorted by object block input" do
+          expect(dv.index_of_min { |x| x.size }).to eq(:t)
+        end
+        it "returns N index of min values, sorted by comparitive block input" do
+          expect(dv.index_of_min(2) {|a,b| a.size <=> b.size}).to eq([:t, :d])
+        end
+        it "returns N index of min values, sorted by object block input" do
+          expect(dv.index_of_min(2) {|x| x.size }).to eq([:t, :d])
+        end
+      end
+
+      context "#max_by" do
+        it "tests alias of max_by to max" do
+          expect(dv.method(:max_by)).to eq(dv.method(:max))
+        end
+      end
+
+      context "#min_by" do
+        it "tests alias of min_by to min" do
+          expect(dv.method(:min_by)).to eq(dv.method(:min))
+        end
+      end
+
+      context "#index_of_max_by" do
+        it "tests alias of index_of_max_by to index_of_max" do
+          expect(dv.method(:index_of_max_by)).to eq(dv.method(:index_of_max))
+        end
+      end
+
+      context "#index_of_min_by" do
+        it "tests alias of index_of_min_by to index_of_min" do
+          expect(dv.method(:index_of_min_by)).to eq(dv.method(:index_of_min))
+        end
+      end
+
       context "#sum_of_squares" do
         it "calcs sum of squares, omits nil values" do
           v = Daru::Vector.new [1,2,3,4,5,6], dtype: dtype
@@ -583,26 +693,38 @@ describe Daru::Vector do
     end
   end
 
-  context "#macd" do
-    it "calculates moving average convergence divergence" do
-      # MACD uses a lot more data than the other ones, so we need a bigger vector
-      data = Daru::Vector.new(
-        File.readlines("spec/fixtures/stock_data.csv").map(&:to_f))
+  RSpec.shared_examples 'correct macd' do |*args|
+    let(:source) { Daru::DataFrame.from_csv('spec/fixtures/macd_data.csv') }
 
-      macd, signal = data.macd
+    # skip initial records during compare as ema is sensitive to
+    # period used.
+    # http://ta-lib.org/d_api/ta_setunstableperiod.html
+    let(:stability_offset) { 90 }
+    let(:delta) { 0.001 }
+    let(:desc) { args.empty? ? '12_26_9' : args.join('_') }
 
-      # check the MACD
-      expect(macd[-1]).to be_within(1e-6).of(3.12e-4)
-      expect(macd[-10]).to be_within(1e-4).of(-1.07e-2)
-      expect(macd[-20]).to be_within(1e-5).of(-5.65e-3)
+    subject { source['price'].macd(*args) }
 
-      # check the signal
-      expect(signal[-1]).to be_within(1e-5).of(-0.00628)
-      expect(signal[-10]).to be_within(1e-5).of(-0.00971)
-      expect(signal[-20]).to be_within(1e-5).of(-0.00338)
+    %w[ macd macdsig macdhist ].each_with_index do |field, i|
+      it do
+        act = subject[i][stability_offset..-1]
+        exp = source["#{field}_#{desc}"][stability_offset..-1]
+        expect(act).to be_all_within(delta).of(exp)
+      end
     end
   end
 
+  describe '#macd' do
+    context 'by default' do
+      it_should_behave_like 'correct macd'
+    end
+
+    context 'custom values for fast, slow, signal' do
+      it_should_behave_like 'correct macd', 6, 13, 4
+    end
+
+  end
+
   context "#cumsum" do
     it "calculates cumulative sum" do
       vector = Daru::Vector.new([1,2,3,4,5,6,7,8,9,10])