daru_lite 0.1.1 → 0.1.2

data/spec/vector/setable_example.rb

@@ -0,0 +1,300 @@
+shared_examples_for 'a setable Vector' do |dtype|
+  describe "#[]=" do
+    context DaruLite::Index do
+      let(:vector) do
+        DaruLite::Vector.new(
+          [1,2,3,4,5],
+          name: :yoga,
+          index: [:yoda, :anakin, :obi, :padme, :r2d2],
+          dtype:
+        )
+      end
+
+      it "assigns at the specified index" do
+        vector[:yoda] = 666
+        expect(vector[:yoda]).to eq(666)
+      end
+
+      it "assigns at the specified Integer index" do
+        vector[0] = 666
+        expect(vector[:yoda]).to eq(666)
+      end
+
+      it "sets dtype to Array if a nil is assigned" do
+        vector[0] = nil
+        expect(vector.dtype).to eq(:array)
+      end
+
+      context 'mixed index Vector' do
+        let(:vector) do
+          DaruLite::Vector.new([1, 2, 3, 4], index: ['a', :a, 0, 66])
+        end
+
+        it "assigns correctly" do
+          vector['a'] = 666
+          expect(vector['a']).to eq(666)
+
+          vector[0] = 666
+          expect(vector[0]).to eq(666)
+
+          vector[3] = 666
+          expect(vector[3]).to eq(666)
+
+          expect(vector).to eq(
+            DaruLite::Vector.new(
+              [666, 2, 666, 666],
+              index: ['a', :a, 0, 66])
+            )
+        end
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      let(:tuples) do
+        [
+          [: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]
+        ]
+      end
+      let(:multi_index) { DaruLite::MultiIndex.from_tuples(tuples) }
+      let(:vector) do
+        DaruLite::Vector.new(
+          Array.new(12) { |i| i },
+          index: multi_index,
+          dtype:,
+          name: :mi_vector
+        )
+      end
+
+      it "assigns all lower layer indices when specified a first layer index" do
+        vector[:b] = 69
+        expect(vector).to eq(
+          DaruLite::Vector.new([0, 1, 2, 3, 69, 69, 69, 69, 8, 9, 10, 11],
+            index: multi_index,
+            name: :top_layer_assignment,
+            dtype:
+          )
+        )
+      end
+
+      it "assigns all lower indices when specified first and second layer index" do
+        vector[:b, :one] = 69
+        expect(vector).to eq(
+          DaruLite::Vector.new([0, 1, 2, 3, 69, 5, 6, 69, 8, 9, 10, 11],
+            index: multi_index,
+            name: :second_layer_assignment,
+            dtype:
+          )
+        )
+      end
+
+      it "assigns just the precise value when specified complete tuple" do
+        vector[:b, :one, :foo] = 69
+        expect(vector).to eq(
+          DaruLite::Vector.new([0, 1, 2, 3, 4, 5, 6, 69, 8, 9, 10, 11],
+            index: multi_index,
+            name: :precise_assignment,
+            dtype:
+          )
+        )
+      end
+
+      it "assigns correctly when numeric index" do
+        vector[7] = 69
+        expect(vector).to eq(
+          DaruLite::Vector.new([0, 1, 2, 3, 4, 5, 6, 69, 8, 9, 10, 11],
+            index: multi_index,
+            name: :precise_assignment,
+            dtype:
+          )
+        )
+      end
+
+      it "fails predictably on unknown index" do
+        expect { vector[:d] = 69 }.to raise_error(IndexError)
+        expect { vector[:b, :three] = 69 }.to raise_error(IndexError)
+        expect { vector[:b, :two, :test] = 69 }.to raise_error(IndexError)
+      end
+    end
+
+    context DaruLite::CategoricalIndex do
+      subject { vector }
+
+      context "non-numerical index" do
+        let (:idx) { DaruLite::CategoricalIndex.new [:a, :b, :a, :a, :c] }
+        let (:vector)  { DaruLite::Vector.new 'a'..'e', index: idx }
+
+        context "single category" do
+          context "multiple instances" do
+            before { vector[:a] = 'x' }
+
+            its(:size) { is_expected.to eq 5 }
+            its(:to_a) { is_expected.to eq  ['x', 'b', 'x', 'x', 'e'] }
+            its(:index) { is_expected.to eq idx }
+          end
+
+          context "single instance" do
+            before { vector[:b] = 'x' }
+
+            its(:size) { is_expected.to eq 5 }
+            its(:to_a) { is_expected.to eq  ['a', 'x', 'c', 'd', 'e'] }
+            its(:index) { is_expected.to eq idx }
+          end
+        end
+
+        context "multiple categories" do
+          before { vector[:a, :c] = 'x' }
+
+          its(:size) { is_expected.to eq 5 }
+          its(:to_a) { is_expected.to eq  ['x', 'b', 'x', 'x', 'x'] }
+          its(:index) { is_expected.to eq idx }
+        end
+
+        context "multiple positional indexes" do
+          before { vector[0, 1, 2] = 'x' }
+
+          its(:size) { is_expected.to eq 5 }
+          its(:to_a) { is_expected.to eq ['x', 'x', 'x', 'd', 'e'] }
+          its(:index) { is_expected.to eq idx }
+        end
+
+        context "single positional index" do
+          before { vector[1] = 'x' }
+
+          its(:size) { is_expected.to eq 5 }
+          its(:to_a) { is_expected.to eq ['a', 'x', 'c', 'd', 'e'] }
+          its(:index) { is_expected.to eq idx }
+        end
+
+        context "invalid category" do
+          it { expect { vector[:x] = 'x' }.to raise_error IndexError }
+        end
+
+        context "invalid positional index" do
+          it { expect { vector[30] = 'x'}.to raise_error IndexError }
+        end
+      end
+
+      context "numerical index" do
+        let (:idx) { DaruLite::CategoricalIndex.new [1, 1, 2, 2, 3] }
+        let (:vector)  { DaruLite::Vector.new 'a'..'e', index: idx }
+
+        context "single category" do
+          before { vector[1] = 'x' }
+
+          its(:size) { is_expected.to eq 5 }
+          its(:to_a) { is_expected.to eq ['x', 'x', 'c', 'd', 'e'] }
+          its(:index) { is_expected.to eq idx }
+        end
+
+        context "multiple categories" do
+          before { vector[1, 2] = 'x' }
+
+          its(:size) { is_expected.to eq 5 }
+          its(:to_a) { is_expected.to eq ['x', 'x', 'x', 'x', 'e'] }
+          its(:index) { is_expected.to eq idx }
+        end
+      end
+    end
+  end
+
+  describe "#set_at" do
+    context DaruLite::Index do
+      let (:idx) { DaruLite::Index.new [1, 0, :c] }
+      let (:dv) { DaruLite::Vector.new ['a', 'b', 'c'], index: idx }
+
+      context "single position" do
+        subject { dv }
+        before { dv.set_at [1], 'x' }
+
+        its(:to_a) { is_expected.to eq ['a', 'x', 'c'] }
+      end
+
+      context "multiple positions" do
+        subject { dv }
+        before { dv.set_at [0, 2], 'x' }
+
+        its(:to_a) { is_expected.to eq ['x', 'b', 'x'] }
+      end
+
+      context "invalid position" do
+        it { expect { dv.set_at [3], 'x' }.to raise_error IndexError }
+      end
+
+      context "invalid positions" do
+        it { expect { dv.set_at [2, 3], 'x' }.to raise_error IndexError }
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      let(:idx) do
+        DaruLite::MultiIndex.from_tuples [
+          [:a,:one,:bar],
+          [:a,:one,:baz],
+          [:b,:two,:bar],
+          [:a,:two,:baz],
+        ]
+      end
+      let(:dv) { DaruLite::Vector.new 1..4, index: idx }
+
+      context "single position" do
+        subject { dv }
+        before { dv.set_at [1], 'x' }
+
+        its(:to_a) { is_expected.to eq [1, 'x', 3, 4] }
+      end
+
+      context "multiple positions" do
+        subject { dv }
+        before { dv.set_at [2, 3], 'x' }
+
+        its(:to_a) { is_expected.to eq [1, 2, 'x', 'x'] }
+      end
+
+      context "invalid position" do
+        it { expect { dv.set_at [4], 'x' }.to raise_error IndexError }
+      end
+
+      context "invalid positions" do
+        it { expect { dv.set_at [2, 4], 'x' }.to raise_error IndexError }
+      end
+    end
+
+    context DaruLite::CategoricalIndex do
+      let (:idx) { DaruLite::CategoricalIndex.new [:a, 1, 1, :a, :c] }
+      let (:dv)  { DaruLite::Vector.new 'a'..'e', index: idx }
+
+      context "multiple positional indexes" do
+        subject { dv }
+        before { dv.set_at [0, 1, 2], 'x' }
+
+        its(:to_a) { is_expected.to eq ['x', 'x', 'x', 'd', 'e'] }
+      end
+
+      context "single positional index" do
+        subject { dv }
+        before { dv.set_at [1], 'x' }
+
+        its(:to_a) { is_expected.to eq ['a', 'x', 'c', 'd', 'e'] }
+      end
+
+      context "invalid position" do
+        it { expect { dv.set_at [5], 'x' }.to raise_error IndexError }
+      end
+
+      context "invalid positions" do
+        it { expect { dv.set_at [2, 5], 'x' }.to raise_error IndexError }
+      end
+    end
+  end
+end

data/spec/vector/sortable_example.rb

@@ -0,0 +1,242 @@
+shared_examples_for 'a sortable Vector' do |dtype|
+  describe "#reorder!" do
+    subject { vector_with_dtype.reorder!([3, 2, 1, 0]) }
+
+    let(:vector_with_dtype) do
+      DaruLite::Vector.new(
+        [1, 2, 3, 4],
+        index: [:a, :b, :c, :d],
+        dtype:
+      )
+    end
+    let(:arranged_vector) do
+      DaruLite::Vector.new([4,3,2,1], index: [:d, :c, :b, :a], dtype:)
+    end
+
+    before { subject }
+
+    it "rearranges with passed order" do
+      expect(vector_with_dtype).to eq arranged_vector
+    end
+
+    it "doesn't change dtype" do
+      expect(vector_with_dtype.data.class).to eq arranged_vector.data.class
+    end
+  end
+
+
+  context "#sort" do
+    context DaruLite::Index do
+      let(:vector) do
+        DaruLite::Vector.new([33, 2, 15, 332, 1], name: :dv, index: [:a, :b, :c, :d, :e])
+      end
+
+      it "sorts the vector with defaults and returns a new vector, preserving indexing" do
+        expect(vector.sort).to eq(
+          DaruLite::Vector.new([1,2,15,33,332], name: :dv, index: [:e, :b, :c, :a, :d])
+        )
+      end
+
+      it "sorts the vector in descending order" do
+        expect(vector.sort(ascending: false)).to eq(
+          DaruLite::Vector.new([332,33,15,2,1], name: :dv, index: [:d, :a, :c, :b, :e])
+        )
+      end
+
+      context 'when a block is passed' do
+        subject { vector.sort { |a,b| a.length <=> b.length } }
+
+        let(:vector) { DaruLite::Vector.new ["My Jazz Guitar", "Jazz", "My", "Guitar"] }
+
+        it "sorts vector accordingly" do
+          expect(subject).to eq(
+            DaruLite::Vector.new(["My", "Jazz", "Guitar", "My Jazz Guitar"], index: [2, 1, 3, 0])
+          )
+        end
+      end
+
+      context 'when vector contains nils and numeric data' do
+        let(:vector) { DaruLite::Vector.new([22, 4, nil, 111, nil, 2]) }
+
+        it "places nils near the beginning of the vector when sorting ascendingly" do
+          expect(vector.sort).to eq(
+            DaruLite::Vector.new([nil, nil, 2, 4, 22, 111], index: [2, 4, 5, 1, 0, 3])
+          )
+        end if dtype == :array
+
+        it "places nils near the beginning of the vector when sorting descendingly" do
+          expect(vector.sort(ascending: false)).to eq(
+            DaruLite::Vector.new [111, 22, 4, 2, nil, nil], index: [3, 0, 1, 5, 4, 2]
+          )
+        end
+      end
+
+      context 'when vector contains nils and non-numeric data' do
+        let(:vector) { DaruLite::Vector.new(['a','b', nil, 'aa', '1234', nil]) }
+
+        it "correctly sorts vector in ascending order" do
+          expect(vector.sort(ascending: true)).to eq(
+            DaruLite::Vector.new([nil, nil, '1234', 'a', 'aa', 'b'], index: [2, 5, 4, 0, 3, 1])
+          )
+        end
+
+        it "correctly sorts vector in descending order" do
+          expect(vector.sort(ascending: false)).to eq(
+            DaruLite::Vector.new(['b', 'aa', 'a', '1234', nil, nil], index: [1, 3, 0, 4, 5, 2])
+          )
+        end
+      end
+    end
+
+    context DaruLite::MultiIndex do
+      let(:multi_index) do
+        DaruLite::MultiIndex.from_tuples([
+          [:a, :one,   :foo],
+          [:a, :two,   :bar],
+          [:b, :one,   :bar],
+          [:b, :two,   :baz],
+          [:b, :three, :bar]
+        ])
+      end
+      let(:vector) do
+        DaruLite::Vector.new(
+          [44, 22, 111, 0, -56],
+          index: multi_index,
+          name: :unsorted,
+          dtype:
+        )
+      end
+
+      it "sorts vector" do
+        mi_asc = DaruLite::MultiIndex.from_tuples([
+          [:b, :three, :bar],
+          [:b, :two,   :baz],
+          [:a, :two,   :bar],
+          [:a, :one,   :foo],
+          [:b, :one,   :bar]
+        ])
+        expect(vector.sort).to eq(
+          DaruLite::Vector.new([-56,0,22,44,111], index: mi_asc, name: :ascending, dtype:)
+        )
+      end
+
+      it "sorts in descending" do
+        mi_dsc = DaruLite::MultiIndex.from_tuples([
+          [:b, :one, :bar],
+          [:a, :one, :foo],
+          [:a, :two, :bar],
+          [:b, :two, :baz],
+          [:b, :three, :bar]
+        ])
+        expect(vector.sort(ascending: false)).to eq(
+          DaruLite::Vector.new([111, 44, 22, 0, -56], index: mi_dsc, name: :descending, dtype:)
+        )
+      end
+
+      it "sorts using the supplied block" do
+        mi_abs = DaruLite::MultiIndex.from_tuples([
+          [:b, :two,   :baz],
+          [:a, :two,   :bar],
+          [:a, :one,   :foo],
+          [:b, :three, :bar],
+          [:b, :one,   :bar]
+        ])
+        expect(vector.sort { |a,b| a.abs <=> b.abs }).to eq(
+          DaruLite::Vector.new([0, 22, 44, -56, 111], index: mi_abs, name: :sort_abs, dtype:)
+        )
+      end
+    end
+
+    context DaruLite::CategoricalIndex do
+      let(:idx) { DaruLite::CategoricalIndex.new [:a, 1, :a, 1, :c] }
+      let(:dv_numeric) { DaruLite::Vector.new [4, 5, 3, 2, 1], index: idx }
+      let(:dv_string) { DaruLite::Vector.new ['xxxx', 'zzzzz', 'ccc', 'bb', 'a'], index: idx }
+      let(:dv_nil) { DaruLite::Vector.new [3, nil, 2, 1, -1], index: idx }
+
+      context "increasing order" do
+        context "numeric" do
+          subject { dv_numeric.sort }
+
+          its(:size) { is_expected.to eq 5 }
+          its(:to_a) { is_expected.to eq [1, 2, 3, 4, 5] }
+          its(:'index.to_a') { is_expected.to eq [:c, 1, :a, :a, 1] }
+        end
+
+        context "non-numeric" do
+          subject { dv_string.sort }
+
+          its(:size) { is_expected.to eq 5 }
+          its(:to_a) { is_expected.to eq ['a', 'bb', 'ccc', 'xxxx', 'zzzzz'] }
+          its(:'index.to_a') { is_expected.to eq [:c, 1, :a, :a, 1] }
+        end
+
+        context "block" do
+          subject { dv_string.sort { |a, b| a.length <=> b.length } }
+
+          its(:to_a) { is_expected.to eq ['a', 'bb', 'ccc', 'xxxx', 'zzzzz'] }
+          its(:'index.to_a') { is_expected.to eq [:c, 1, :a, :a, 1] }
+        end
+
+        context "nils" do
+          subject { dv_nil.sort }
+
+          its(:to_a) { is_expected.to eq [nil, -1, 1, 2, 3] }
+          its(:'index.to_a') { is_expected.to eq [1, :c, 1, :a, :a] }
+        end
+      end
+
+      context "decreasing order" do
+        context "numeric" do
+          subject { dv_numeric.sort(ascending: false) }
+
+          its(:size) { is_expected.to eq 5 }
+          its(:to_a) { is_expected.to eq [5, 4, 3, 2, 1] }
+          its(:'index.to_a') { is_expected.to eq [1, :a, :a, 1, :c] }
+        end
+
+        context "non-numeric" do
+          subject { dv_string.sort(ascending: false) }
+
+          its(:size) { is_expected.to eq 5 }
+          its(:to_a) { is_expected.to eq ['zzzzz', 'xxxx', 'ccc', 'bb', 'a'] }
+          its(:'index.to_a') { is_expected.to eq [1, :a, :a, 1, :c] }
+        end
+
+        context "block" do
+          subject do
+            dv_string.sort(ascending: false) { |a, b| a.length <=> b.length }
+          end
+
+          its(:to_a) { is_expected.to eq ['zzzzz', 'xxxx', 'ccc', 'bb', 'a'] }
+          its(:'index.to_a') { is_expected.to eq [1, :a, :a, 1, :c] }
+        end
+
+        context "nils" do
+          subject { dv_nil.sort(ascending: false) }
+
+          its(:to_a) { is_expected.to eq [3, 2, 1, -1, nil] }
+          its(:'index.to_a') { is_expected.to eq [:a, :a, 1, :c, 1] }
+        end
+      end
+    end
+  end
+
+  describe "#sort_by_index" do
+    let(:asc) { vector.sort_by_index }
+    let(:desc) { vector.sort_by_index(ascending: false) }
+
+    context 'numeric vector' do
+      let(:vector) { DaruLite::Vector.new [11, 13, 12], index: [23, 21, 22] }
+
+      specify { expect(asc.to_a).to eq [13, 12, 11] }
+      specify { expect(desc.to_a).to eq [11, 12, 13] }
+    end
+
+    context 'mix variable type index' do
+      let(:vector) { DaruLite::Vector.new [11, Float::NAN, nil], index: [21, 23, 22] }
+
+      specify { expect(asc.to_a).to eq [11, nil, Float::NAN] }
+      specify { expect(desc.to_a).to eq [Float::NAN, nil, 11] }
+    end
+  end
+end