daru_lite 0.1

data/spec/iruby/vector_spec.rb

@@ -0,0 +1,105 @@
+describe DaruLite::Vector, '#to_html' do
+  [nil, :category].each do |type|
+    let(:doc) { Nokogiri::HTML(vector.to_html) }
+    subject(:table) { doc.at('table') }
+    let(:header) { doc.at('b') }
+
+    context 'simple' do
+      let(:vector) { DaruLite::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(:text) { is_expected.to eq " DaruLite::Vector(3)"\
+          "#{":category" if type == :category} " }
+      end
+
+      describe 'name' do
+        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) { DaruLite::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) { DaruLite::Vector.new [1,2,3] * 100, name: 'test', type: type }
+      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(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(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) {
+        DaruLite::Vector.new(
+          [1,2,3,4,5,6,7],
+          name: 'test',
+          type: type,
+          index: DaruLite::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(:text) { is_expected.to eq " DaruLite::Vector(7)"\
+          "#{":category" if type == :category} " }
+      end
+
+      describe 'name row' do
+        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('tbody > tr:first-child') }
+        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/maths/arithmetic/dataframe_spec.rb

@@ -0,0 +1,148 @@
+describe DaruLite::DataFrame do
+  before(:each) do
+    @df = DaruLite::DataFrame.new({a: [1,2,3,4,5], b: ['a','e','i','o','u'],
+      c: [10,20,30,40,50]})
+    @left = DaruLite::DataFrame.new({a: [1,nil,nil,4], b: [10,nil,nil,40], c: [5,6,7,8]},
+      index: [0,4,5,3])
+    @right = DaruLite::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(DaruLite::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(DaruLite::DataFrame.new({
+        a: [2,nil,nil,8,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
+  end
+
+  context "#-" do
+    it "subtracts a number from all numeric vectors" do
+      expect(@df - 2).to eq(DaruLite::DataFrame.new({
+        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(DaruLite::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 all numeric vectors by number" do
+      expect(@df * 2).to eq(DaruLite::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(DaruLite::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(DaruLite::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(DaruLite::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(DaruLite::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(DaruLite::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(DaruLite::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(DaruLite::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,
+        DaruLite::DataFrame.new({
+          a: [1.0,1.41421356,1.73205080,2.0,2.23606797],
+          c: [3.16227766, 4.47213595 ,5.47722557 ,6.32455532, 7.07106781]
+        }), 0.001
+      )
+    end
+  end
+
+  context "#round" do
+    it "rounds to precision" do
+      df = DaruLite::DataFrame.new({
+        a: [1.3434,2.4332,5.6655,12.3344,32.233],
+        b: [1.3434,2.4332,5.6655,12.3344,32.233],
+        c: %w(a b c d e)
+      })
+      ans = DaruLite::DataFrame.new({
+        a: [1.34,2.43,5.67,12.33,32.23],
+        b: [1.34,2.43,5.67,12.33,32.23],
+      })
+
+      expect(df.round(2)).to eq(ans)
+    end
+  end
+
+  context "#exp" do
+    it "calculates exponential" do
+      e = Math::E
+      df = DaruLite::DataFrame.new({
+        a: [1,2,3],
+        b: [4,5,6],
+        c: %w(a b c)
+      })
+      ans = DaruLite::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

data/spec/maths/arithmetic/vector_spec.rb

@@ -0,0 +1,165 @@
+describe DaruLite::Vector do
+  let(:dv1) { described_class.new(values1, name: :boozy, index: indexes1) }
+  let(:dv2) { described_class.new(values2, name: :mayer, index: indexes2) }
+  let(:with_md1) do
+    described_class.new([1, 2, 3, nil, 5, nil], name: :missing, index: indexes_with_md1)
+  end
+  let(:with_md2) do
+    described_class.new([1, 2, 3, nil, 5, nil], name: :missing, index: [:obi, :wan, :corona, :a, :b, :c])
+  end
+  let(:values1) { [1, 2, 3, 4] }
+  let(:values2) { [1, 2, 3, 4] }
+  let(:indexes1) { [:bud, :kf, :henie, :corona] }
+  let(:indexes2) { [:obi, :wan, :kf, :corona] }
+  let(:indexes1_and_2) { [:bud, :corona, :henie, :kf, :obi, :wan] }
+  let(:indexes_with_md1) { [:a, :b, :c, :obi, :wan, :corona] }
+  let(:indexes_with_md1_and_2) { [:a, :b, :c, :corona, :obi, :wan] }
+
+  describe "#+" do
+    it "adds matching indexes of the other vector" do
+      expect(dv1 + dv2).to eq(
+        DaruLite::Vector.new([nil, 8, nil, 5, nil, nil], name: :boozy, index: indexes1_and_2)
+      )
+    end
+
+    it "adds number to each element of the entire vector" do
+      expect(dv1 + 5).to eq(DaruLite::Vector.new(values1.map { |v| v + 5 }, name: :boozy, index: indexes1))
+    end
+
+    it "does not add when a number is being added" do
+      expect(with_md1 + 1).to eq(
+        DaruLite::Vector.new([2, 3, 4, nil, 6, nil], name: :missing, index: indexes_with_md1)
+      )
+    end
+
+    it "puts a nil when one of the operands is nil" do
+      expect(with_md1 + with_md2).to eq(
+        DaruLite::Vector.new([nil, 7, nil, nil, nil, 7], name: :missing, index: indexes_with_md1_and_2)
+      )
+    end
+
+    context 'when vectors have numeric and non-numeric indexes' do
+      let(:indexes1) { nil }
+      let(:indexes2) { [:a, :b, :c, :d] }
+
+      it "appropriately adds vectors with numeric and non-numeric indexes" do
+        expect(dv1 + dv2).to eq(DaruLite::Vector.new(Array.new(6), index: [0, 1, 2, 3] + indexes2))
+      end
+    end
+
+    context 'when index contains symbols and strings' do
+      let(:indexes1) { [:bud, 'kf', :henie, :corona] }
+      let(:indexes2) { [:obi, :wan, 'kf', :corona] }
+
+      it "adds matching indexes of the other vector" do
+        expect(dv1 + dv2).to eq(
+          DaruLite::Vector.new([nil, 8, nil, 5, nil, nil], name: :boozy, index: [:bud, :corona, :henie, 'kf', :obi, :wan])
+        )
+      end
+    end
+  end
+
+  describe "#-" do
+    it "subtracts matching indexes of the other vector" do
+      expect(dv1 - dv2).to eq(
+        DaruLite::Vector.new([nil, 0, nil, -1, nil, nil], name: :boozy, index: indexes1_and_2)
+      )
+    end
+
+    it "subtracts number from each element of the entire vector" do
+      expect(dv1 - 5).to eq(DaruLite::Vector.new(values1.map { |v| v - 5 }, name: :boozy, index: indexes1))
+    end
+  end
+
+  describe "#*" do
+    it "multiplies matching indexes of the other vector" do
+      expect(dv1 * dv2).to eq(
+        DaruLite::Vector.new([nil, 16, nil, 6, nil, nil], name: :boozy, index: indexes1_and_2)
+      )
+    end
+
+    it "multiplies number to each element of the entire vector" do
+      expect(dv1 * 5).to eq(DaruLite::Vector.new(values1.map { |v| v * 5 }, name: :boozy, index: indexes1))
+    end
+  end
+
+  describe "#\/" do
+    let(:values2) { [1.0, 2.0, 3.0, 4.0] }
+
+    it "divides matching indexes of the other vector" do
+      expect(dv1 / dv2).to eq(
+        DaruLite::Vector.new([nil, 1.0, nil, 2 / 3.to_f, nil, nil], name: :boozy, index: indexes1_and_2)
+      )
+    end
+
+    it "divides number from each element of the entire vector" do
+      expect(dv1 / 5.0).to eq(DaruLite::Vector.new(values1.map { |v| v / 5.0 }, name: :boozy, index: indexes1))
+    end
+  end
+
+  describe "#%" do
+    it "applies % to matching indexes of the other vector" do
+      expect(dv1 % dv2).to eq(DaruLite::Vector.new([nil, 0, nil, 2, nil, nil], name: :boozy, index: indexes1_and_2))
+    end
+
+    it "applies % for each element of the entire vector" do
+      expect(dv1 % 5).to eq(
+        DaruLite::Vector.new(values1.map { |v| v % 5 }, name: :boozy, index: indexes1)
+      )
+    end
+  end
+
+  describe "#**" do
+    it "applies ** to matching indexes of the other vector" do
+      expect(dv1 ** dv2).to eq(DaruLite::Vector.new([nil, 256, nil, 8, nil, nil], name: :boozy, index: indexes1_and_2))
+    end
+
+    it "applies ** for each element of the entire vector" do
+      expect(dv1 ** 5).to eq(DaruLite::Vector.new(values1.map { |v| v ** 5 }, name: :boozy, index: indexes1))
+    end
+  end
+
+  describe "#exp" do
+    it "calculates exp of all numbers" do
+      expect(with_md1.exp.round(3)).to eq(
+        DaruLite::Vector.new(
+          [2.718281828459045, 7.38905609893065, 20.085536923187668, nil, 148.4131591025766, nil],
+          index: indexes_with_md1,
+          name: :missing
+        ).round(3)
+      )
+    end
+  end
+
+  describe "#add" do
+    it "adds two vectors with nils as 0 if skipnil is true" do
+      expect(with_md1.add(with_md2, skipnil: true)).to eq(
+        DaruLite::Vector.new([1, 7, 3, 3, 1, 7], name: :missing, index: indexes_with_md1_and_2)
+      )
+    end
+
+    it "adds two vectors same as :+ if skipnil is false" do
+      expect(with_md1.add(with_md2, skipnil: false)).to eq(
+        DaruLite::Vector.new([nil, 7, nil, nil, nil, 7], name: :missing, index: indexes_with_md1_and_2)
+      )
+    end
+  end
+
+  describe "#abs" do
+    it "calculates abs value" do
+      with_md1.abs
+    end
+  end
+
+  describe "#sqrt" do
+    it "calculates sqrt" do
+      with_md1.sqrt
+    end
+  end
+
+  describe "#round" do
+    it "rounds to given precision" do
+      with_md1.round(2)
+    end
+  end
+end

data/spec/maths/statistics/dataframe_spec.rb

@@ -0,0 +1,178 @@
+describe DaruLite::DataFrame do
+  before do
+    @df = DaruLite::DataFrame.new({
+      a: ['foo'  ,  'foo',  'foo',  'foo',  'foo',  'bar',  'bar',  'bar',  'bar'],
+      b: ['one'  ,  'one',  'one',  'two',  'two',  'one',  'one',  'two',  'two'],
+      c: ['small','large','large','small','small','large','small','large','small'],
+      d: [1,2,2,3,3,4,5,6,7],
+      e: [2,4,4,6,6,8,10,12,14],
+      f: [10,20,20,30,30,40,50,60,70]
+    })
+  end
+
+  context "#mean" do
+    it "calculates mean of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.mean.round(2)).to eq(DaruLite::Vector.new([3.67, 7.33, 36.67],
+        index: [:d, :e, :f]
+      ))
+    end
+
+    it "calculates mean of multi level numeric only vectors and returns values in a DataFrame" do
+      # TODO - pending
+    end
+  end
+
+  context "#variance_sample" do
+    it "calculates variance of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.variance_sample).to eq(DaruLite::Vector.new([4.0, 16.0, 400.0], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#std" do
+    it "calculates standard deviation of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.std).to eq(DaruLite::Vector.new([2, 4, 20], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#sum" do
+    it "calculates sum of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.sum).to eq(DaruLite::Vector.new([33, 66, 330], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#count" do
+    it "counts number of non-nil single level numeric only vectors and returns values in a Vector" do
+      expect(@df.count).to eq(DaruLite::Vector.new([9, 9, 9], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#mode" do
+    it "calculates mode of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.mode).to eq(DaruLite::Vector.new([DaruLite::Vector.new([2,3]), DaruLite::Vector.new([4,6]), DaruLite::Vector.new([20,30])], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#median" do
+    it "calculates median of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.median).to eq(DaruLite::Vector.new([3, 6, 30], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#max" do
+    it "returns the row that has max" do
+      df = DaruLite::DataFrame.new({
+        a: [1,2,3,4,5],
+        b: ['aa','aaa','a','','dfffdf'],
+        c: [11,22,33,44,55]
+      })
+      expect(df.max(vector: :b)).to eq(
+        DaruLite::Vector.new([5,'dfffdf',55], index: [:a, :b, :c]))
+    end
+  end
+
+  context "#min" do
+    it "calculates mininum of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.min).to eq(DaruLite::Vector.new([1, 2, 10], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#range" do
+    it "calculates range of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.range).to eq(DaruLite::Vector.new([6, 12, 60], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#product" do
+    it "calculates product of single level numeric only vectors and returns values in a Vector" do
+      expect(@df.product).to eq(DaruLite::Vector.new([30240, 15482880, 30240000000000], index: [:d, :e, :f]))
+    end
+  end
+
+  context "#describe" do
+    it "generates mean, std, max, min and count of numeric vectors in one shot" do
+      expect(@df.describe.round(2)).to eq(DaruLite::DataFrame.new({
+        d: [9.00, 3.67 ,2.00 , 1.00,  7.00],
+        e: [9.00, 7.33 ,4.00 , 2.00, 14.00],
+        f: [9.00, 36.67,20.00,10.00, 70.00]
+        }, index: [:count, :mean, :std, :min, :max]
+      ))
+    end
+  end
+
+  context "percent_change" do
+    it "calculates percent change of numeric vectors" do
+      expect(@df.percent_change.round(2)).to eq(DaruLite::DataFrame.new({
+        d: [nil, 1.0, 0.0, 0.5, 0.0, 0.33, 0.25, 0.2, 0.17],
+        e: [nil, 1.0, 0.0, 0.5, 0.0, 0.33, 0.25, 0.2, 0.17],
+        f: [nil, 1.0, 0.0, 0.5, 0.0, 0.33, 0.25, 0.2, 0.17] }
+      ))
+    end
+  end
+
+  context "#cov" do
+    it "calculates the variance covariance of the numeric vectors of DataFrame" do
+      expect(@df.cov).to eq(DaruLite::DataFrame.new({
+        d: [4,8,40],
+        e: [8,16,80],
+        f: [40,80,400]
+        }, index: [:d, :e, :f]
+      ))
+
+      test = DaruLite::DataFrame.rows([
+        [0.3543,0.4535,0.2424],
+        [0.123,0.53323,0.544],
+        [0.4345,0.4552,0.425]
+      ], order: [:a, :b, :c])
+      ans = DaruLite::DataFrame.new({
+        a: [0.0261607, -0.0071019, -0.0153640],
+        b: [-0.0071019, 0.0020747, 0.0056071],
+        c: [-0.0153640, 0.0056071, 0.0230777]
+      })
+
+      test.cov.each_vector_with_index do |v, i|
+        expect_correct_vector_in_delta v, ans[i], 0.01
+      end
+    end
+  end
+
+  context "#corr" do
+    it "calculates the correlation between the numeric vectors of DataFrame" do
+      expect(@df.corr).to eq(DaruLite::DataFrame.new({
+        d: [1,1,1],
+        e: [1,1,1],
+        f: [1,1,1]
+        }, index: [:d, :e, :f]
+      ))
+    end
+  end
+
+  context "#cumsum" do
+    it "calculates cumulative sum of numeric vectors" do
+      answer = DaruLite::DataFrame.new({
+        d: [1,3,5,8,11,15,20,26,33],
+        e: [2,6,10,16,22,30,40,52,66],
+        f: [10,30,50,80,110,150,200,260,330]
+        })
+      expect(@df.cumsum).to eq(answer)
+    end
+  end
+
+  context "#rolling_mean" do
+    it "calculates rolling mean" do
+      v = DaruLite::Vector.new([17.28, 17.45, 17.84, 17.74, 17.82, 17.85, 17.36, 17.3, 17.56, 17.49, 17.46, 17.4, 17.03, 17.01,16.86, 16.86, 16.56, 16.36, 16.66, 16.77])
+      df = DaruLite::DataFrame.new({ a: v, b: v, c: v })
+      answer = df.rolling_mean
+
+      expect(answer[:a][-1]) .to be_within(0.001).of(16.897)
+      expect(answer[:b][-5]) .to be_within(0.001).of(17.233)
+      expect(answer[:c][-10]).to be_within(0.001).of(17.587)
+    end
+  end
+
+  context "#standardize" do
+    it "standardizes" do
+      # TODO: Write this test.
+      @df.standardize
+    end
+  end
+end