daru_lite 0.1.1 → 0.1.2

data/spec/data_frame/fetchable_example.rb

@@ -0,0 +1,476 @@
+shared_examples_for 'a fetchable DataFrame' do
+  describe "#[]" do
+    context DaruLite::Index do
+      let(:df) do
+        DaruLite::DataFrame.new(
+          {
+            b: [11,12,13,14,15],
+            a: [1,2,3,4,5],
+            c: [11,22,33,44,55]
+          },
+          order: [:a, :b, :c],
+          index: [:one, :two, :three, :four, :five]
+        )
+      end
+
+      it "returns a Vector" do
+        expect(df[:a]).to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
+      end
+
+      it "returns a Vector by default" do
+        expect(df[:a]).to eq(DaruLite::Vector.new([1,2,3,4,5], name: :a,
+          index: [:one, :two, :three, :four, :five]))
+      end
+
+      it "returns a DataFrame" do
+        temp = DaruLite::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5]},
+          order: [:a, :b], index: [:one, :two, :three, :four, :five])
+
+        expect(df[:a, :b]).to eq(temp)
+      end
+
+      it "accesses vector with Integer index" do
+        expect(df[0]).to eq([1,2,3,4,5].dv(:a, [:one, :two, :three, :four, :five]))
+      end
+
+      it "returns a subset of DataFrame when specified range" do
+        subset = df[:b..:c]
+        expect(subset).to eq(DaruLite::DataFrame.new({
+          b: [11,12,13,14,15],
+          c: [11,22,33,44,55]
+          }, index: [:one, :two, :three, :four, :five]))
+      end
+
+      it 'accepts axis parameter as a last argument' do
+        expect(df[:a, :vector]).to eq df[:a]
+        expect(df[:one, :row]).to eq [1, 11, 11].dv(:one, [:a, :b, :c])
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      it "accesses vector with an integer index" do
+        expect(df_mi[0]).to eq(
+          DaruLite::Vector.new(vector_arry1, index: multi_index))
+      end
+
+      it "returns a vector when specifying full tuple" do
+        expect(df_mi[:a, :one, :bar]).to eq(
+          DaruLite::Vector.new(vector_arry1, index: multi_index))
+      end
+
+      it "returns DataFrame when specified first layer of MultiIndex" do
+        sub_order = DaruLite::MultiIndex.from_tuples([
+          [:one, :bar],
+          [:two, :baz]
+          ])
+        expect(df_mi[:a]).to eq(
+          DaruLite::DataFrame.new([vector_arry1, vector_arry2], index: multi_index, order: sub_order)
+        )
+      end
+
+      it "returns a Vector if the last level of MultiIndex is tracked" do
+        expect(df_mi[:a, :one, :bar]).to eq(
+          DaruLite::Vector.new(vector_arry1, index: multi_index)
+        )
+      end
+    end
+  end
+
+  describe "#at" do
+    context DaruLite::Index do
+      let(:idx) { DaruLite::Index.new [:a, :b, :c] }
+      let(:df) do
+        DaruLite::DataFrame.new({
+          1 => 1..3,
+          a: 'a'..'c',
+          b: 11..13
+        }, index: idx)
+      end
+
+      context "single position" do
+        subject { df.at 1 }
+
+        it { is_expected.to be_a DaruLite::Vector }
+        its(:size) { is_expected.to eq 3 }
+        its(:to_a) { is_expected.to eq ['a', 'b', 'c'] }
+        its(:index) { is_expected.to eq idx }
+      end
+
+      context "multiple positions" do
+        subject { df.at 0, 2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 2] }
+        its(:index) { is_expected.to eq idx }
+        it { expect(df[1].to_a).to eq [1, 2, 3] }
+        its(:'b.to_a') { is_expected.to eq [11, 12, 13] }
+      end
+
+      context "single invalid position" do
+        it { expect { df. at 3 }.to raise_error IndexError }
+      end
+
+      context "multiple invalid positions" do
+        it { expect { df.at 2, 3 }.to raise_error IndexError }
+      end
+
+      context "range" do
+        subject { df.at 0..1 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 2] }
+        its(:index) { is_expected.to eq idx }
+        it { expect(df[1].to_a).to eq [1, 2, 3] }
+        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
+      end
+
+      context "range with negative end" do
+        subject { df.at 0..-2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 2] }
+        its(:index) { is_expected.to eq idx }
+        it { expect(df[1].to_a).to eq [1, 2, 3] }
+        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
+      end
+
+      context "range with single element" do
+        subject { df.at 1..1 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 1] }
+        its(:index) { is_expected.to eq idx }
+        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      let (:idx) do
+        DaruLite::MultiIndex.from_tuples [
+          [:a,:one,:bar],
+          [:a,:one,:baz],
+          [:b,:two,:bar],
+        ]
+      end
+      let(:df) do
+        DaruLite::DataFrame.new({
+          1 => 1..3,
+          a: 'a'..'c',
+          b: 11..13
+        }, index: idx)
+      end
+
+      context "single position" do
+        subject { df.at 1 }
+
+        it { is_expected.to be_a DaruLite::Vector }
+        its(:size) { is_expected.to eq 3 }
+        its(:to_a) { is_expected.to eq ['a', 'b', 'c'] }
+        its(:index) { is_expected.to eq idx }
+      end
+
+      context "multiple positions" do
+        subject { df.at 0, 2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 2] }
+        its(:index) { is_expected.to eq idx }
+        it { expect(df[1].to_a).to eq [1, 2, 3] }
+        its(:'b.to_a') { is_expected.to eq [11, 12, 13] }
+      end
+
+      context "single invalid position" do
+        it { expect { df. at 3 }.to raise_error IndexError }
+      end
+
+      context "multiple invalid positions" do
+        it { expect { df.at 2, 3 }.to raise_error IndexError }
+      end
+
+      context "range" do
+        subject { df.at 0..1 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 2] }
+        its(:index) { is_expected.to eq idx }
+        it { expect(df[1].to_a).to eq [1, 2, 3] }
+        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
+      end
+
+      context "range with negative end" do
+        subject { df.at 0..-2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 2] }
+        its(:index) { is_expected.to eq idx }
+        it { expect(df[1].to_a).to eq [1, 2, 3] }
+        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
+      end
+
+      context "range with single element" do
+        subject { df.at 1..1 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 1] }
+        its(:index) { is_expected.to eq idx }
+        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
+      end
+    end
+
+    context DaruLite::CategoricalIndex do
+      let (:idx) { DaruLite::CategoricalIndex.new [:a, 1, 1] }
+      let(:df) do
+        DaruLite::DataFrame.new({
+          1 => 1..3,
+          a: 'a'..'c',
+          b: 11..13
+        }, index: idx)
+      end
+
+      context "single position" do
+        subject { df.at 1 }
+
+        it { is_expected.to be_a DaruLite::Vector }
+        its(:size) { is_expected.to eq 3 }
+        its(:to_a) { is_expected.to eq ['a', 'b', 'c'] }
+        its(:index) { is_expected.to eq idx }
+      end
+
+      context "multiple positions" do
+        subject { df.at 0, 2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 2] }
+        its(:index) { is_expected.to eq idx }
+        it { expect(df[1].to_a).to eq [1, 2, 3] }
+        its(:'b.to_a') { is_expected.to eq [11, 12, 13] }
+      end
+
+      context "single invalid position" do
+        it { expect { df. at 3 }.to raise_error IndexError }
+      end
+
+      context "multiple invalid positions" do
+        it { expect { df.at 2, 3 }.to raise_error IndexError }
+      end
+
+      context "range" do
+        subject { df.at 0..1 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 2] }
+        its(:index) { is_expected.to eq idx }
+        it { expect(df[1].to_a).to eq [1, 2, 3] }
+        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
+      end
+
+      context "range with negative index" do
+        subject { df.at 0..-2 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 2] }
+        its(:index) { is_expected.to eq idx }
+        it { expect(df[1].to_a).to eq [1, 2, 3] }
+        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
+      end
+
+      context "range with single element" do
+        subject { df.at 1..1 }
+
+        it { is_expected.to be_a DaruLite::DataFrame }
+        its(:shape) { is_expected.to eq [3, 1] }
+        its(:index) { is_expected.to eq idx }
+        its(:'a.to_a') { is_expected.to eq ['a', 'b', 'c'] }
+      end
+    end
+  end
+
+  context "#first" do
+    it 'works' do
+      expect(df.first(2)).to eq(
+        DaruLite::DataFrame.new({b: [11,12], a: [1,2], c: [11,22]},
+        order: [:a, :b, :c],
+        index: [:one, :two]))
+    end
+
+    it 'works with too large values' do
+      expect(df.first(200)).to eq(df)
+    end
+
+    it 'has synonym' do
+      expect(df.first(2)).to eq(df.head(2))
+    end
+
+    it 'works on DateTime indexes' do
+      idx = DaruLite::DateTimeIndex.new(['2017-01-01', '2017-02-01', '2017-03-01'])
+      df = DaruLite::DataFrame.new({col1: ['a', 'b', 'c']}, index: idx)
+      first = DaruLite::DataFrame.new({col1: ['a']}, index: DaruLite::DateTimeIndex.new(['2017-01-01']))
+      expect(df.head(1)).to eq(first)
+    end
+  end
+
+  context "#last" do
+    it 'works' do
+      expect(df.last(2)).to eq(
+        DaruLite::DataFrame.new({b: [14,15], a: [4,5], c: [44,55]},
+        order: [:a, :b, :c],
+        index: [:four, :five]))
+    end
+
+    it 'works with too large values' do
+      expect(df.last(200)).to eq(df)
+    end
+
+    it 'has synonym' do
+      expect(df.last(2)).to eq(df.tail(2))
+    end
+  end
+
+  context '#access_row_tuples_by_indexs' do
+    let(:df) {
+      DaruLite::DataFrame.new({col: [:a, :b, :c, :d, :e], num: [52,12,07,17,01]}) }
+    let(:df_idx) {
+      DaruLite::DataFrame.new({a: [52, 12, 07], b: [1, 2, 3]}, index: [:one, :two, :three])
+    }
+    let (:mi_idx) do
+      DaruLite::MultiIndex.from_tuples [
+        [:a,:one,:bar],
+        [:a,:one,:baz],
+        [:b,:two,:bar],
+        [:a,:two,:baz],
+      ]
+    end
+    let (:df_mi) do
+      DaruLite::DataFrame.new({
+        a: 1..4,
+        b: 'a'..'d'
+      }, index: mi_idx )
+    end
+    context 'when no index is given' do
+      it 'returns empty Array' do
+        expect(df.access_row_tuples_by_indexs()).to eq([])
+      end
+    end
+    context 'when index(s) are given' do
+      it 'returns Array of row tuples' do
+        expect(df.access_row_tuples_by_indexs(1)).to eq([[:b, 12]])
+        expect(df.access_row_tuples_by_indexs(0,3)).to eq([[:a, 52], [:d, 17]])
+      end
+    end
+    context 'when custom index(s) are given' do
+      it 'returns Array of row tuples' do
+        expect(df_idx.access_row_tuples_by_indexs(:one,:three)).to eq(
+          [[52, 1], [7, 3]]
+        )
+      end
+    end
+    context 'when multi index is given' do
+      it 'returns Array of row tuples' do
+        expect(df_mi.access_row_tuples_by_indexs(:a)).to eq(
+          [[1, "a"], [2, "b"], [4, "d"]]
+        )
+        expect(df_mi.access_row_tuples_by_indexs(:a, :one, :baz)).to eq(
+          [[2, "b"]]
+        )
+      end
+    end
+  end
+
+  context "#only_numerics" do
+    subject { df.only_numerics }
+
+    let(:df) do
+      DaruLite::DataFrame.new({a: vector1, b: vector2, c: vector3 }, clone: false)
+    end
+    let(:vector1) { DaruLite::Vector.new([1,2,3,4,5]) }
+    let(:vector2) { DaruLite::Vector.new(%w(one two three four five)) }
+    let(:vector3) { DaruLite::Vector.new([11,22,33,44,55]) }
+
+    it "returns a clone of numeric vectors" do
+      expect(subject).to eq(
+        DaruLite::DataFrame.new({ a: vector1, c: vector3}, clone: false)
+      )
+      expect(subject[:a].object_id).to_not eq(vector1.object_id)
+    end
+
+    context 'clone is false' do
+      subject { df.only_numerics(clone: false) }
+
+      it "returns a view of only the numeric vectors" do
+        expect(subject).to eq(
+          DaruLite::DataFrame.new({ a: vector1, c: vector3 }, clone: false)
+        )
+        expect(subject[:a].object_id).to eq(vector1.object_id)
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      let(:df) do
+        order = 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]
+          ]
+        )
+
+        index = DaruLite::MultiIndex.from_tuples(
+          [
+            [:bar],
+            [:foo]
+          ]
+        )
+        DaruLite::DataFrame.new(
+          [
+            [4.112,2.234],
+            %w(a b),
+            [6.342,nil],
+            [7.2344,3.23214],
+            [8.234,4.533],
+            [10.342,2.3432],
+            [12.0,nil],
+            %w(a b)
+          ],
+          order:,
+          index:
+        )
+      end
+
+      it "returns numeric vectors" do
+        vectors = DaruLite::MultiIndex.from_tuples(
+          [
+            [:d, :one, :large],
+            [:d, :two, :large],
+            [:d, :two, :small],
+            [:e, :one, :large],
+            [:e, :one, :small],
+            [:e, :two, :large]
+          ]
+        )
+        index = DaruLite::MultiIndex.from_tuples(
+          [
+            [:bar],
+            [:foo]
+          ]
+        )
+        answer = DaruLite::DataFrame.new(
+          [
+            [4.112,2.234],
+            [6.342,nil],
+            [7.2344,3.23214],
+            [8.234,4.533],
+            [10.342,2.3432],
+            [12.0,nil],
+          ], order: vectors, index: index
+        )
+
+        expect(subject).to eq(answer)
+      end
+    end
+  end
+end