daru_lite 0.1.1 → 0.1.2

data/spec/data_frame/pivotable_example.rb

@@ -0,0 +1,297 @@
+shared_examples_for 'a pivotable DataFrame' do
+  describe "#pivot_table" do
+    let(:df) do
+      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]
+      })
+    end
+
+    it "creates row index as per (single) index argument and default aggregates to mean" do
+      expect(df.pivot_table(index: [:a])).to eq(DaruLite::DataFrame.new({
+        d: [5.5,2.2],
+        e: [11.0,4.4]
+      }, index: ['bar', 'foo']))
+    end
+
+    it "creates row index as per (double) index argument and default aggregates to mean" do
+      agg_mi = DaruLite::MultiIndex.from_tuples(
+        [
+          ['bar', 'large'],
+          ['bar', 'small'],
+          ['foo', 'large'],
+          ['foo', 'small']
+        ]
+      )
+      expect(df.pivot_table(index: [:a, :c]).round(2)).to eq(DaruLite::DataFrame.new({
+        d: [5.0 ,  6.0, 2.0, 2.33],
+        e: [10.0, 12.0, 4.0, 4.67]
+      }, index: agg_mi))
+    end
+
+    it "creates row and vector index as per (single) index and (single) vectors args" do
+      agg_vectors = DaruLite::MultiIndex.from_tuples([
+        [:d, 'one'],
+        [:d, 'two'],
+        [:e, 'one'],
+        [:e, 'two']
+      ])
+      agg_index = DaruLite::MultiIndex.from_tuples(
+        [
+          ['bar'],
+          ['foo']
+        ]
+      )
+
+      expect(df.pivot_table(index: [:a], vectors: [:b]).round(2)).to eq(
+        DaruLite::DataFrame.new(
+          [
+            [4.5, 1.67],
+            [6.5,  3.0],
+            [9.0, 3.33],
+            [13,     6]
+          ], order: agg_vectors, index: agg_index)
+      )
+    end
+
+    it "creates row and vector index as per (single) index and (double) vector args" do
+      agg_vectors = DaruLite::MultiIndex.from_tuples(
+        [
+          [:d, 'one', 'large'],
+          [:d, 'one', 'small'],
+          [:d, 'two', 'large'],
+          [:d, 'two', 'small'],
+          [:e, 'one', 'large'],
+          [:e, 'one', 'small'],
+          [:e, 'two', 'large'],
+          [:e, 'two', 'small']
+        ]
+      )
+
+      agg_index = DaruLite::MultiIndex.from_tuples(
+        [
+          ['bar'],
+          ['foo']
+        ]
+      )
+
+      expect(df.pivot_table(index: [:a], vectors: [:b, :c])).to eq(DaruLite::DataFrame.new(
+        [
+          [4.0,2.0],
+          [5.0,1.0],
+          [6.0,nil],
+          [7.0,3.0],
+          [8.0,4.0],
+          [10.0,2.0],
+          [12.0,nil],
+          [14.0,6.0]
+        ], order: agg_vectors, index: agg_index
+      ))
+    end
+
+    it "creates row and vector index with (double) index and (double) vector args" do
+      agg_index = DaruLite::MultiIndex.from_tuples([
+        ['bar', 4],
+        ['bar', 5],
+        ['bar', 6],
+        ['bar', 7],
+        ['foo', 1],
+        ['foo', 2],
+        ['foo', 3]
+      ])
+
+      agg_vectors = DaruLite::MultiIndex.from_tuples([
+        [:e, 'one', 'large'],
+        [:e, 'one', 'small'],
+        [:e, 'two', 'large'],
+        [:e, 'two', 'small']
+      ])
+
+      expect(df.pivot_table(index: [:a, :d], vectors: [:b, :c])).to eq(
+        DaruLite::DataFrame.new(
+          [
+            [8  ,nil,nil,nil,nil,  4,nil],
+            [nil, 10,nil,nil,  2,nil,nil],
+            [nil,nil, 12,nil,nil,nil,nil],
+            [nil,nil,nil, 14,nil,nil,  6],
+          ], index: agg_index, order: agg_vectors)
+      )
+    end
+
+    it "only aggregates over the vector specified in the values argument" do
+      agg_vectors = DaruLite::MultiIndex.from_tuples(
+        [
+          [:e, 'one', 'large'],
+          [:e, 'one', 'small'],
+          [:e, 'two', 'large'],
+          [:e, 'two', 'small']
+        ]
+      )
+      agg_index = DaruLite::MultiIndex.from_tuples(
+        [
+          ['bar'],
+          ['foo']
+        ]
+      )
+      expect(df.pivot_table(index: [:a], vectors: [:b, :c], values: :e)).to eq(
+        DaruLite::DataFrame.new(
+          [
+            [8,   4],
+            [10,  2],
+            [12,nil],
+            [14,  6]
+          ], order: agg_vectors, index: agg_index
+        )
+      )
+
+      agg_vectors = DaruLite::MultiIndex.from_tuples(
+        [
+          [:d, 'one'],
+          [:d, 'two'],
+          [:e, 'one'],
+          [:e, 'two']
+        ]
+      )
+      expect(df.pivot_table(index: [:a], vectors: [:b], values: [:d, :e])).to eq(
+        DaruLite::DataFrame.new(
+          [
+            [4.5,  5.0/3],
+            [6.5,    3.0],
+            [9.0, 10.0/3],
+            [13.0,   6.0]
+          ], order: agg_vectors, index: agg_index
+        )
+      )
+    end
+
+    it "overrides default aggregate function to aggregate over sum" do
+      agg_vectors = DaruLite::MultiIndex.from_tuples(
+        [
+          [:e, 'one', 'large'],
+          [:e, 'one', 'small'],
+          [:e, 'two', 'large'],
+          [:e, 'two', 'small']
+        ]
+      )
+      agg_index = DaruLite::MultiIndex.from_tuples(
+        [
+          ['bar'],
+          ['foo']
+        ]
+      )
+      expect(df.pivot_table(index: [:a], vectors: [:b, :c], values: :e, agg: :sum)).to eq(
+        DaruLite::DataFrame.new(
+          [
+            [8,   8],
+            [10,  2],
+            [12,nil],
+            [14, 12]
+          ], order: agg_vectors, index: agg_index
+        )
+      )
+    end
+
+    it "raises error if no non-numeric vectors are present" do
+      df = DaruLite::DataFrame.new({a: ['a', 'b', 'c'], b: ['b', 'e', 'd']})
+      expect {
+        df.pivot_table(index: [:a])
+      }.to raise_error
+    end
+
+    it "raises error if atleast a row index is not specified" do
+      expect {
+        df.pivot_table
+      }.to raise_error
+    end
+
+    it "aggregates when nils are present in value vector" do
+      df = DaruLite::DataFrame.new({
+        a: ['foo'  ,  'foo',  'foo',  'foo',  'foo',  'bar',  'bar',  'bar',  'ice'],
+        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,nil,4,6,6,8,10,12,nil]
+      })
+
+      expect(df.pivot_table index: [:a]).to eq(
+        DaruLite::DataFrame.new({
+          d:  [5.0, 2.2, 7],
+          e:  [10.0, 4.5, nil]
+        }, index: DaruLite::Index.new(['bar', 'foo', 'ice'])))
+    end
+
+    it "works when nils are present in value vector" do
+      df = DaruLite::DataFrame.new({
+        a: ['foo'  ,  'foo',  'foo',  'foo',  'foo',  'bar',  'bar',  'bar',  'ice'],
+        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,nil,4,6,6,8,10,12,nil]
+      })
+
+      agg_vectors = DaruLite::MultiIndex.from_tuples(
+        [
+          [:e, 'one'],
+          [:e, 'two']
+        ]
+      )
+
+      agg_index = DaruLite::MultiIndex.from_tuples(
+        [
+          ['bar'],
+          ['foo'],
+          ['ice']
+        ]
+      )
+
+      expect(df.pivot_table index: [:a], vectors: [:b], values: :e).to eq(
+        DaruLite::DataFrame.new(
+          [
+            [9, 3,  nil],
+            [12, 6, nil]
+          ], order: agg_vectors, index: agg_index
+        )
+      )
+    end
+
+    it 'performs date pivoting' do
+      categories = %i[jan feb mar apr may jun jul aug sep oct nov dec]
+      df = DaruLite::DataFrame.rows([
+        [2014, 2, 1600.0, 20.0],
+        [2014, 3, 1680.0, 21.0],
+        [2016, 2, 1600.0, 20.0],
+        [2016, 4, 1520.0, 19.0],
+      ], order: [:year, :month, :visitors, :days])
+      df[:averages] = df[:visitors] / df[:days]
+      df[:month] = df[:month].map{|i| categories[i - 1]}
+      actual = df.pivot_table(index: :month, vectors: [:year], values: :averages)
+
+      # NB: As you can see, there are some "illogical" parts:
+      #     months are sorted lexicographically, then made into multi-index
+      #     with one-element-per-tuple, then order of columns is dependent
+      #     on which month is lexicographically first (its apr, so, apr-2016
+      #     is first row to gather, so 2016 is first column).
+      #
+      #     All of it is descendance of our group_by implementation (which
+      #     always sorts results & always make array keys). I hope that fixing
+      #     group_by, even to the extend described at https://github.com/v0dro/daru/issues/152,
+      #     will be fix this case also.
+      expected =
+        DaruLite::DataFrame.new(
+          [
+            [80.0, 80.0, nil],
+            [nil, 80.0, 80.0],
+          ], index: DaruLite::MultiIndex.from_tuples([[:apr], [:feb], [:mar]]),
+          order: DaruLite::MultiIndex.from_tuples([[:averages, 2016], [:averages, 2014]])
+        )
+      # Comparing their parts previous to full comparison allows to
+      # find complicated differences.
+      expect(actual.vectors).to eq expected.vectors
+      expect(actual.index).to eq expected.index
+      expect(actual).to eq expected
+    end
+  end
+end

data/spec/data_frame/queryable_example.rb

@@ -0,0 +1,92 @@
+shared_examples_for 'a queryable DataFrame' do
+  describe '#include_values?' do
+    let(:df) do
+      DaruLite::DataFrame.new({
+        a: [1,   2,  3,   4,          Float::NAN, 6, 1],
+        b: [:a,  :b, nil, Float::NAN, nil,        3, 5],
+        c: ['a', 6,  3,   4,          3,          5, 3],
+        d: [1,   2,  3,   5,          1,          2, 5]
+      })
+    end
+    before { df.to_category :b }
+
+    context 'true' do
+      it { expect(df.include_values? nil).to eq true }
+      it { expect(df.include_values? Float::NAN).to eq true }
+      it { expect(df.include_values? nil, Float::NAN).to eq true }
+      it { expect(df.include_values? 1, 30).to eq true }
+    end
+
+    context 'false' do
+      it { expect(df[:a, :c].include_values? nil).to eq false }
+      it { expect(df[:c, :d].include_values? Float::NAN).to eq false }
+      it { expect(df[:c, :d].include_values? nil, Float::NAN).to eq false }
+      it { expect(df.include_values? 10, 20).to eq false }
+    end
+  end
+
+
+  describe "#any?" do
+    let(:df) do
+      DaruLite::DataFrame.new(
+        {
+          a: [1,2,3,4,5],
+          b: [10,20,30,40,50],
+          c: [11,22,33,44,55]
+        }
+      )
+    end
+
+    it "returns true if any one of the vectors satisfy condition" do
+      expect(df.any? { |v| v[0] == 1 }).to eq(true)
+    end
+
+    it "returns false if none of the vectors satisfy the condition" do
+      expect(df.any? { |v| v.mean > 100 }).to eq(false)
+    end
+
+    it "returns true if any one of the rows satisfy condition" do
+      expect(df.any?(:row) { |r| r[:a] == 1 and r[:c] == 11 }).to eq(true)
+    end
+
+    it "returns false if none of the rows satisfy the condition" do
+      expect(df.any?(:row) { |r| r.mean > 100 }).to eq(false)
+    end
+
+    it 'fails on unknown axis' do
+      expect { df.any?(:kitten) { |r| r.mean > 100 } }.to raise_error ArgumentError, /axis/
+    end
+  end
+
+  describe "#all?" do
+    let(:df) do
+      DaruLite::DataFrame.new(
+        {
+          a: [1,2,3,4,5],
+          b: [10,20,30,40,50],
+          c: [11,22,33,44,55]
+        }
+      )
+    end
+
+    it "returns true if all of the vectors satisfy condition" do
+      expect(df.all? { |v| v.mean < 40 }).to eq(true)
+    end
+
+    it "returns false if any one of the vectors does not satisfy condition" do
+      expect(df.all? { |v| v.mean == 30 }).to eq(false)
+    end
+
+    it "returns true if all of the rows satisfy condition" do
+      expect(df.all?(:row) { |r| r.mean < 70 }).to eq(true)
+    end
+
+    it "returns false if any one of the rows does not satisfy condition" do
+      expect(df.all?(:row) { |r| r.mean == 30 }).to eq(false)
+    end
+
+    it 'fails on unknown axis' do
+      expect { df.all?(:kitten) { |r| r.mean > 100 } }.to raise_error ArgumentError, /axis/
+    end
+  end
+end