daru_lite 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fca8a59ee849230424502a8ffa2f986134ccf522d15d53ab3807c22b64b30f8
-  data.tar.gz: 8c4e8048ea8171c463b048ac9dff8b86a8b19e3ec5dd62f16bf72311e7b03b38
+  metadata.gz: fe2a3da2352dd68322a62e048c7870ad34f243a31bcd0cf18725b15583e4c5e8
+  data.tar.gz: 889d0714e1188240f43dc741f2b58b0ce3fe8731a07b39ee4d366f54ce301f6b
 SHA512:
-  metadata.gz: 403d6cfe869dcd152f083ea0878be37f6a8b40212f6ba5f80ece21bcadf51a4f13471f529bbddcf66b593568f31ec52f3e308c39160f0bd87bac9af6d95b30f6
-  data.tar.gz: dfbc2d7b5e63c54980c704c0df3d96ae8d079b921fc0ff51a34f109126a2a382d531457321737e83a2b03bc114b741e3018d0beb9cb00554aa822345d94f3144
+  metadata.gz: 370f64692790e1661642c2e40ec4b56baa8fd8ac000be5623293013b169b7d96c0e5d5fe122801bbea40945761710b0b94c148fae27c67a42ab1825683416876
+  data.tar.gz: ebb89b2307548a0deaeda39e8e72a899a0f4e20c0e5a5ee16515c7aaea5ac95e8f7da3dc752b80a7dba64ec2f4e19717ba3703c06ee0793111c36da968ed5b02

data/lib/daru_lite/dataframe.rb

@@ -289,8 +289,8 @@ module DaruLite
     def delete_at_position(position)
       raise IndexError, "Position #{position} does not exist." unless position < size
 
-      each_vector { |vector| vector.delete_at_position(position) }
       @index = @index.delete_at(position)
+      each_vector { |vector| vector.delete_at_position(position) }
 
       set_size
     end

data/lib/daru_lite/index/index.rb

@@ -200,7 +200,7 @@ module DaruLite
     end
 
     def to_a
-      @keys
+      @keys.dup
     end
 
     def key(value)

data/lib/daru_lite/index/multi_index.rb

@@ -196,6 +196,15 @@ module DaruLite
       DaruLite::MultiIndex.from_tuples(to_a + [indexes])
     end
 
+    # Takes a positional value and returns a new Index without the element at given position
+    # @param position [Integer] positional value
+    # @return [object] index object
+    def delete_at(position)
+      indexes = to_a
+      indexes.delete_at(position)
+      self.class.from_tuples(indexes)
+    end
+
     def reorder(new_order)
       from = to_a
       MultiIndex.from_tuples(new_order.map { |i| from[i] })

data/lib/daru_lite/version.rb

@@ -1,3 +1,3 @@
 module DaruLite
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.1.3'.freeze
 end

data/spec/data_frame/filterable_example.rb

@@ -128,8 +128,6 @@ shared_examples_for 'a filterable DataFrame' do
   end
 
   describe "#keep_row_if" do
-    subject { df.keep_row_if { |row| row[:a] % 10 == 0 } }
-
     let(:index) { [:one, :two, :three, :four, :five] }
     let(:order) { [:a, :b, :c] }
     let(:df)  do
@@ -143,33 +141,194 @@ shared_examples_for 'a filterable DataFrame' do
       )
     end
 
-    context DaruLite::Index do
+    shared_examples_for '#keep_row_if' do
+      before { subject }
+
       it "keeps row if block evaluates to true" do
-        subject
-        expect(df).to eq(
+        expect(df).to eq(expected_df)
+      end
+
+      it 'returns correct index' do
+        expect(df.index).to eq(expected_index)
+      end
+
+      it "all vectors have the same index" do
+        expect(df.map(&:index)).to all(eq(expected_index))
+      end
+    end
+
+    context 'a single row is removed' do
+      context DaruLite::Index do
+        subject { df.keep_row_if { |row| row.name != :four } }
+
+        let(:expected_index) { DaruLite::Index.new([:one, :two, :three, :five]) }
+        let(:expected_df) do
           DaruLite::DataFrame.new(
-            { b: [10, 12, 20], a: [50, 30, 30], c: [10, 20, 30] },
+            { b: [10, 12, 20, 30], a: [50, 30, 30, 5], c: [10, 20, 30, 50] },
             order:,
-            index: index[..2]
+            index: expected_index
           )
-        )
+        end
+
+        it_behaves_like '#keep_row_if'
+      end
+
+      context DaruLite::CategoricalIndex do
+        subject { df.keep_row_if { |row| row.name != :a } }
+
+        let (:index) { DaruLite::CategoricalIndex.new([:a, 1, 1, :a, :c]) }
+        let(:expected_index) { DaruLite::CategoricalIndex.new([1, 1, :c]) }
+        let(:expected_df) do
+          DaruLite::DataFrame.new(
+            {
+              b: [12, 20, 30],
+              a: [30, 30, 5],
+              c: [20, 30, 50]
+            },
+            order:,
+            index: expected_index
+          )
+        end
+
+        it_behaves_like '#keep_row_if'
+      end
+
+      context DaruLite::MultiIndex do
+        subject { df.keep_row_if { |row| !row.name.include?('two') } }
+
+        let(:index) do
+          DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one], [:b, :two], [:c, :one]])
+        end
+        let(:expected_index) do
+          DaruLite::MultiIndex.from_tuples([[:a, :one], [:b, :one], [:c, :one]])
+        end
+        let(:expected_df) do
+          DaruLite::DataFrame.new(
+            {
+              b: [10, 20, 30],
+              a: [50, 30, 5],
+              c: [10, 30, 50]
+            },
+            order:,
+            index: expected_index
+          )
+        end
+
+        it_behaves_like '#keep_row_if'
       end
     end
 
-    context DaruLite::CategoricalIndex do
-      let (:index) { DaruLite::CategoricalIndex.new([:a, 1, 1, :a, :c]) }
+    context 'several rows are removed' do
+      subject { df.keep_row_if { |row| row[:a] % 10 == 0 } }
 
-      it "keeps row if block evaluates to true" do
-        subject
-        expect(df).to eq(
+      context DaruLite::Index do
+        let(:expected_index) { DaruLite::Index.new([:one, :two, :three]) }
+        let(:expected_df) do
+          DaruLite::DataFrame.new(
+            { b: [10, 12, 20], a: [50, 30, 30], c: [10, 20, 30] },
+            order:,
+            index: expected_index
+          )
+        end
+
+        it_behaves_like '#keep_row_if'
+      end
+
+      context DaruLite::CategoricalIndex do
+        let (:index) { DaruLite::CategoricalIndex.new([:a, 1, 1, :a, :c]) }
+        let(:expected_index) { DaruLite::CategoricalIndex.new([:a, 1, 1]) }
+        let(:expected_df) do
           DaruLite::DataFrame.new(
             { b: [10, 12, 20], a: [50, 30, 30], c: [10, 20, 30] },
             order:,
-            index: DaruLite::CategoricalIndex.new([:a, 1, 1])
+            index: expected_index
           )
-        )
+        end
+
+        it_behaves_like '#keep_row_if'
+      end
+
+      context DaruLite::MultiIndex do
+        let(:index) { DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one], [:b, :two], [:c, :one]]) }
+        let(:expected_index) do
+          DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one]])
+        end
+        let(:expected_df) do
+          DaruLite::DataFrame.new(
+            { b: [10, 12, 20], a: [50, 30, 30], c: [10, 20, 30] },
+            order:,
+            index: expected_index
+          )
+        end
+
+        it_behaves_like '#keep_row_if'
       end
     end
+
+    # context DaruLite::MultiIndex do
+    #   subject { df.keep_row_if { |row| row.name != 'No answer' } }
+
+    #   let(:df) do
+    #     order = DaruLite::MultiIndex.from_tuples(
+    #       [
+    #         [:a, :total],
+    #         [:a, "Male"],
+    #         [:a, "Female"],
+    #         [:a, "Prefer not to answer"],
+    #         [:a, "No answer"],
+    #         [:b, :total],
+    #         [:b, "Male"],
+    #         [:b, "Female"],
+    #         [:b, "Prefer not to answer"],
+    #         [:b, "No answer"],
+    #         [:c, :total],
+    #         [:c, "Male"],
+    #         [:c, "Female"],
+    #         [:c, "Prefer not to answer"],
+    #         [:c, "No answer"]
+    #       ]
+    #     )
+    #     index = [
+    #       :base,
+    #       "Single Malt Whisky",
+    #       "Blended/ Other Whisky",
+    #       "Vodka",
+    #       "Cognac",
+    #       "Brandy",
+    #       "Rum",
+    #       "Gin",
+    #       "Tequila",
+    #       "No answer",
+    #       "NET"
+    #     ]
+    #     DaruLite::DataFrame.new(
+    #       [
+    #         [0.0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [Float::NAN, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [nil, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #         [0, nil, nil, nil, nil, nil, nil, nil, nil],
+    #       ],
+    #       index:,
+    #       order:
+    #     )
+    #   end
+
+    #   it "all vectors have the same index" do
+    #     subject
+    #     expect(df.map(&:index)).to all(eq(df.index))
+    #   end
+    # end
   end
 
   describe "#keep_vector_if" do

data/spec/index/categorical_index_spec.rb

@@ -1,36 +1,47 @@
 require 'spec_helper.rb'
 
 describe DaruLite::CategoricalIndex do
+  let(:index) { described_class.new(keys) }
+  let(:keys) { [:a, :b, :a, :a, :c] }
+
+  describe "#to_a" do
+    subject { index.to_a }
+
+    it { is_expected.to eq(keys) }
+
+    it 'the returns array is not a variable of the index' do
+      expect { subject << 'four' }.not_to change { index.to_a }
+    end
+  end
+
   context "#pos" do
     context "when the category is non-numeric" do
-      let(:idx) { described_class.new [:a, :b, :a, :a, :c] }
-
       context "single category" do
-        subject { idx.pos :a }
+        subject { index.pos :a }
 
         it { is_expected.to eq [0, 2, 3] }
       end
 
       context "multiple categories" do
-        subject { idx.pos :a, :c }
+        subject { index.pos :a, :c }
 
         it { is_expected.to eq [0, 2, 3, 4] }
       end
 
       context "invalid category" do
-        it { expect { idx.pos :e }.to raise_error IndexError }
+        it { expect { index.pos :e }.to raise_error IndexError }
       end
 
       context "positional index" do
-        it { expect(idx.pos 0).to eq 0 }
+        it { expect(index.pos 0).to eq 0 }
       end
 
       context "invalid positional index" do
-        it { expect { idx.pos 5 }.to raise_error IndexError }
+        it { expect { index.pos 5 }.to raise_error IndexError }
       end
 
       context "multiple positional indexes" do
-        subject { idx.pos 0, 1, 2 }
+        subject { index.pos 0, 1, 2 }
 
         it { is_expected.to be_a Array }
         its(:size) { is_expected.to eq 3 }
@@ -167,4 +178,12 @@ describe DaruLite::CategoricalIndex do
       it { expect(idx.valid? :a, 1, 5).to eq false }
     end
   end
+
+  describe '#delete_at' do
+    subject { index.delete_at(3) }
+
+    let(:index) { described_class.new([:a, 1, :a, 1, 'c']) }
+
+    it { is_expected.to eq(described_class.new([:a, 1, :a, 'c'])) }
+  end
 end

data/spec/index/index_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper.rb'
 
 describe DaruLite::Index do
+  let(:index) { described_class.new(keys) }
+  let(:keys) { ['one', 'two', 'three'] }
+
   context ".new" do
     it "creates an Index object if Index-like data is supplied" do
       i = DaruLite::Index.new [:one, 'one', 1, 2, :two]
@@ -147,6 +150,16 @@ describe DaruLite::Index do
     end
   end
 
+  describe "#to_a" do
+    subject { index.to_a }
+
+    it { is_expected.to eq(keys) }
+
+    it 'the returns array is not a variable of the index' do
+      expect { subject << 'four' }.not_to change { index.to_a }
+    end
+  end
+
   context "#&" do
     before :each do
       @left = DaruLite::Index.new [:miles, :geddy, :eric]
@@ -390,11 +403,11 @@ describe DaruLite::Index do
   end
 
   describe '#delete_at' do
-    subject { idx.delete_at(1)}
+    subject { index.delete_at(1) }
 
-    let(:idx) { DaruLite::Index.new([:a, :b, 1, 2]) }
+    let(:index) { described_class.new([:a, :b, 1, 2]) }
 
-    it { is_expected.to eq DaruLite::Index.new([:a, 1, 2]) }
+    it { is_expected.to eq(described_class.new([:a, 1, 2])) }
   end
 
   context '#to_df' do

data/spec/index/multi_index_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper.rb'
 
 describe DaruLite::MultiIndex do
-  before(:each) do
-    @index_tuples = [
-      [: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]
+  let(:index) { described_class.from_tuples(index_tuples) }
+  let(:index_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]
     ]
-    @multi_mi = DaruLite::MultiIndex.from_tuples(@index_tuples)
   end
 
   context ".initialize" do
@@ -71,16 +71,16 @@ describe DaruLite::MultiIndex do
 
       it "raises SizeError for wrong number of name" do
         error_msg = "\'names\' and \'levels\' should be of same size. Size of the \'name\' array is 2 and size of the MultiIndex \'levels\' and \'labels\' is 3.\nIf you do not want to set name for particular level (say level \'i\') then put empty string on index \'i\' of the \'name\' Array."
-        expect { @multi_mi.name = ['n1', 'n2'] }.to raise_error(SizeError, error_msg)
+        expect { index.name = ['n1', 'n2'] }.to raise_error(SizeError, error_msg)
 
         error_msg = "'names' and 'levels' should be of same size. Size of the 'name' array is 0 and size of the MultiIndex 'levels' and 'labels' is 3.\nIf you do not want to set name for particular level (say level 'i') then put empty string on index 'i' of the 'name' Array."
-        expect { @multi_mi.name = [ ] }.to raise_error(SizeError, error_msg)
+        expect { index.name = [ ] }.to raise_error(SizeError, error_msg)
 
         error_msg = "'names' and 'levels' should be of same size. Size of the 'name' array is 1 and size of the MultiIndex 'levels' and 'labels' is 3.\nIf you do not want to set name for particular level (say level 'i') then put empty string on index 'i' of the 'name' Array."
-        expect { @multi_mi.name = [''] }.to raise_error(SizeError, error_msg)
+        expect { index.name = [''] }.to raise_error(SizeError, error_msg)
 
         error_msg = "'names' and 'levels' should be of same size. Size of the 'name' array is 4 and size of the MultiIndex 'levels' and 'labels' is 3."
-        expect { @multi_mi.name = ['n1', 'n2', 'n3', 'n4'] }.to raise_error(SizeError, error_msg)
+        expect { index.name = ['n1', 'n2', 'n3', 'n4'] }.to raise_error(SizeError, error_msg)
       end
     end
   end
@@ -101,8 +101,8 @@ describe DaruLite::MultiIndex do
     end
 
     it "creates a triple layer MultiIndex from tuples" do
-      expect(@multi_mi.levels).to eq([[:a,:b,:c], [:one, :two],[:bar,:baz,:foo]])
-      expect(@multi_mi.labels).to eq([
+      expect(index.levels).to eq([[:a,:b,:c], [:one, :two],[:bar,:baz,:foo]])
+      expect(index.labels).to eq([
         [0,0,0,0,1,1,1,1,2,2,2,2],
         [0,0,1,1,0,1,1,0,0,0,1,1],
         [0,1,0,1,0,0,1,2,0,1,2,0]
@@ -132,23 +132,23 @@ describe DaruLite::MultiIndex do
 
   context "#size" do
     it "returns size of MultiIndex" do
-      expect(@multi_mi.size).to eq(12)
+      expect(index.size).to eq(12)
     end
   end
 
   context "#[]" do
     it "returns the row number when specifying the complete tuple" do
-      expect(@multi_mi[:a, :one, :baz]).to eq(1)
+      expect(index[:a, :one, :baz]).to eq(1)
     end
 
     it "returns MultiIndex when specifying incomplete tuple" do
-      expect(@multi_mi[:b]).to eq(DaruLite::MultiIndex.from_tuples([
+      expect(index[:b]).to eq(DaruLite::MultiIndex.from_tuples([
         [:b,:one,:bar],
         [:b,:two,:bar],
         [:b,:two,:baz],
         [:b,:one,:foo]
       ]))
-      expect(@multi_mi[:b, :one]).to eq(DaruLite::MultiIndex.from_tuples([
+      expect(index[:b, :one]).to eq(DaruLite::MultiIndex.from_tuples([
         [:b,:one,:bar],
         [:b,:one,:foo]
       ]))
@@ -156,7 +156,7 @@ describe DaruLite::MultiIndex do
     end
 
     it "returns MultiIndex when specifying wholly numeric ranges" do
-      expect(@multi_mi[3..6]).to eq(DaruLite::MultiIndex.from_tuples([
+      expect(index[3..6]).to eq(DaruLite::MultiIndex.from_tuples([
         [:a,:two,:baz],
         [:b,:one,:bar],
         [:b,:two,:bar],
@@ -165,11 +165,11 @@ describe DaruLite::MultiIndex do
     end
 
     it "raises error when specifying invalid index" do
-      expect { @multi_mi[:a, :three] }.to raise_error IndexError
-      expect { @multi_mi[:a, :one, :xyz] }.to raise_error IndexError
-      expect { @multi_mi[:x] }.to raise_error IndexError
-      expect { @multi_mi[:x, :one] }.to raise_error IndexError
-      expect { @multi_mi[:x, :one, :bar] }.to raise_error IndexError
+      expect { index[:a, :three] }.to raise_error IndexError
+      expect { index[:a, :one, :xyz] }.to raise_error IndexError
+      expect { index[:x] }.to raise_error IndexError
+      expect { index[:x, :one] }.to raise_error IndexError
+      expect { index[:x, :one, :bar] }.to raise_error IndexError
     end
 
     it "works with numerical first levels" do
@@ -189,93 +189,89 @@ describe DaruLite::MultiIndex do
     end
   end
 
+  describe "#to_a" do
+    subject { index.to_a }
+
+    it { is_expected.to eq(index_tuples) }
+
+    it 'the returns array is not a variable of the index' do
+      expect { subject << [:d, :one, :bar] }.not_to change { index.to_a }
+    end
+  end
+
   context "#include?" do
     it "checks if a completely specified tuple exists" do
-      expect(@multi_mi.include?([:a,:one,:bar])).to eq(true)
+      expect(index.include?([:a,:one,:bar])).to eq(true)
     end
 
     it "checks if a top layer incomplete tuple exists" do
-      expect(@multi_mi.include?([:a])).to eq(true)
+      expect(index.include?([:a])).to eq(true)
     end
 
     it "checks if a middle layer incomplete tuple exists" do
-      expect(@multi_mi.include?([:a, :one])).to eq(true)
+      expect(index.include?([:a, :one])).to eq(true)
     end
 
     it "checks for non-existence of completely specified tuple" do
-      expect(@multi_mi.include?([:b, :two, :foo])).to eq(false)
+      expect(index.include?([:b, :two, :foo])).to eq(false)
     end
 
     it "checks for non-existence of a top layer incomplete tuple" do
-      expect(@multi_mi.include?([:d])).to eq(false)
+      expect(index.include?([:d])).to eq(false)
     end
 
     it "checks for non-existence of a middle layer incomplete tuple" do
-      expect(@multi_mi.include?([:c, :three])).to eq(false)
+      expect(index.include?([:c, :three])).to eq(false)
     end
   end
 
   context "#key" do
     it "returns the tuple of the specified number" do
-      expect(@multi_mi.key(3)).to eq([:a,:two,:baz])
+      expect(index.key(3)).to eq([:a,:two,:baz])
     end
 
     it "returns nil for non-existent pointer number" do
       expect {
-        @multi_mi.key(100)
+        index.key(100)
       }.to raise_error ArgumentError
     end
   end
 
   context "#to_a" do
     it "returns tuples as an Array" do
-      expect(@multi_mi.to_a).to eq(@index_tuples)
+      expect(index.to_a).to eq(index_tuples)
     end
   end
 
   context "#dup" do
     it "completely duplicates the object" do
-      duplicate = @multi_mi.dup
-      expect(duplicate)          .to eq(@multi_mi)
-      expect(duplicate.object_id).to_not eq(@multi_mi.object_id)
+      duplicate = index.dup
+      expect(duplicate)          .to eq(index)
+      expect(duplicate.object_id).to_not eq(index.object_id)
     end
   end
 
   context "#inspect" do
     context 'small index' do
-      subject {
-        DaruLite::MultiIndex.from_tuples [
-          [: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]
-        ]
-      }
-
-      its(:inspect) { is_expected.to eq %Q{
-        |#<DaruLite::MultiIndex(12x3)>
-        |   a one bar
-        |         baz
-        |     two bar
-        |         baz
-        |   b one bar
-        |     two bar
-        |         baz
-        |     one foo
-        |   c one bar
-        |         baz
-        |     two foo
-        |         bar
+      subject { index.inspect }
+
+      it do
+        is_expected.to eq %Q{
+          |#<DaruLite::MultiIndex(12x3)>
+          |   a one bar
+          |         baz
+          |     two bar
+          |         baz
+          |   b one bar
+          |     two bar
+          |         baz
+          |     one foo
+          |   c one bar
+          |         baz
+          |     two foo
+          |         bar
         }.unindent
-      }
+      end
     end
 
     context 'large index' do
@@ -331,7 +327,7 @@ describe DaruLite::MultiIndex do
 
     context 'multi index with name having empty string' do
       subject {
-        mi= DaruLite::MultiIndex.new(
+        DaruLite::MultiIndex.new(
                   levels: [[:a,:b,:c],[:one,:two],[:bar, :baz, :foo]],
                   labels: [
                     [0,0,0,0,1,1,1,1,2,2,2,2],
@@ -677,4 +673,17 @@ describe DaruLite::MultiIndex do
            'col3' => %w[bar bar baz foo]
     )}
   end
+
+  describe '#delete_at' do
+    subject { index.delete_at(3)}
+
+    let(:index) do
+      DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one], [:b, :two], [:c, :one]])
+    end
+    let(:expected_index) do
+      DaruLite::MultiIndex.from_tuples([[:a, :one], [:a, :two], [:b, :one], [:c, :one]])
+    end
+
+    it { is_expected.to eq(expected_index) }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daru_lite
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Thomas Naude-Filonnière
@@ -12,7 +12,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-05 00:00:00.000000000 Z
+date: 2024-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord