daru_lite 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c158868ddcdfad0c071d5ad8b583605e86cdd3a005714df2071d0fc122e88278
-  data.tar.gz: 56d1feb6d2b95f6a4c897589c56c32e8890fe72c9eb2e72d6b71a91ffc9e95ae
+  metadata.gz: f09114a32c50e38bfbf8d224919b444a820db2998e46443aa89a999fa856f8f5
+  data.tar.gz: 0c27255f631de63d92d01b576cf42e3880e7453e8d20edfcda3969cea6f32ce3
 SHA512:
-  metadata.gz: 5ac43007818f83995648bdbc65c5debc0d8999c9623271f0d6ca7c70bccc99904b74ec48fd99860a38ad6d02f99493fecdffb6560cbf92fd6a6682eb1190c0a5
-  data.tar.gz: 3f980b1dd60846f9aba374663e34fbd0118396079e1366f7e0046c288087adbf0f7f606853dec915dd9b42109f30e2f25033ea277533a711f5be8ab2948e58f3
+  metadata.gz: f9afdb5835447f5de2af1e7dba83592a8fb5dc4c6981f388609b3408386d03de69ad7a3382e53830d0636d522c462a2b43e988dd38336b67531d8a3ac2e4041a
+  data.tar.gz: a47dfc18efa0b88bd6eaf1179b0cb9d6edf9e054124ee6606f857885862af7c2324c06d23dff4e8b585ff9084c394c8e5d1fb9c29a5f3a3e7b73374888ecac8a

data/lib/daru_lite/data_frame/duplicatable.rb

@@ -10,7 +10,13 @@ module DaruLite
       # * +vectors_to_dup+ - An Array specifying the names of Vectors to
       # be duplicated. Will duplicate the entire DataFrame if not specified.
       def dup(vectors_to_dup = nil)
-        vectors_to_dup ||= @vectors.to_a
+        # No argument: copy by position so a MultiIndex with duplicate tuples (which cannot be
+        # re-looked-up unambiguously by name) is preserved intact.
+        if vectors_to_dup.nil?
+          return DaruLite::DataFrame.new(
+            @data.map(&:dup), order: @vectors.dup, index: @index.dup, name: @name, clone: true
+          )
+        end
 
         src = vectors_to_dup.map { |vec| @data[@vectors.pos(vec)].dup }
         new_order = DaruLite::Index.new(vectors_to_dup)

data/lib/daru_lite/data_frame/fetchable.rb

@@ -226,7 +226,7 @@ module DaruLite
 
         return @data[pos] if pos.is_a?(Integer)
 
-        new_vectors = pos.map { |tuple| @data[@vectors[tuple]] }
+        new_vectors = @vectors.positions_for(names.flatten).map { |position| @data[position] }
 
         pos = pos.drop_left_level(names.size) if names.size < @vectors.width
 

data/lib/daru_lite/data_frame/iterable.rb

@@ -25,8 +25,11 @@ module DaruLite
       def each_vector_with_index
         return to_enum(:each_vector_with_index) unless block_given?
 
-        @vectors.each do |vector|
-          yield @data[@vectors[vector]], vector
+        # Snapshot the data/name pairing up front so the block may safely mutate the DataFrame
+        # (e.g. add vectors) mid-iteration, and pair by position so duplicate MultiIndex tuples
+        # don't trigger an ambiguous name lookup.
+        @data.zip(@vectors.to_a).each do |vector, vector_index| # rubocop:disable Style/ExplicitBlockArgument -- preserve 2-arg yield semantics
+          yield vector, vector_index
         end
 
         self

data/lib/daru_lite/data_frame/sortable.rb

@@ -158,18 +158,26 @@ module DaruLite
 
       private
 
+      # Resolve a sort-key name to a single integer position. A MultiIndex with duplicate tuples
+      # maps a name to several positions; sorting by such a key uses the first match.
+      def sort_vector_position(name)
+        @vectors.is_a?(MultiIndex) ? @vectors.positions_for(name).first : @vectors[name]
+      end
+
       def convert_categorical_vectors(names)
         names.filter_map do |n|
-          next unless self[n].category?
+          position = sort_vector_position(n)
+          vector = @data[position]
+          next unless vector.category?
 
-          old = [n, self[n]]
-          self[n] = DaruLite::Vector.new(self[n].to_ints)
+          old = [position, vector]
+          @data[position] = DaruLite::Vector.new(vector.to_ints)
           old
         end
       end
 
       def restore_categorical_vectors(old)
-        old.each { |name, vector| self[name] = vector }
+        old.each { |position, vector| @data[position] = vector }
       end
 
       def sort_build_row(vector_locs, by_blocks, ascending, handle_nils, r1, r2) # rubocop:disable  Metrics/ParameterLists
@@ -223,7 +231,7 @@ module DaruLite
         handle_nils = sort_coerce_boolean opts, :handle_nils, false, vector_order.size
 
         by_blocks = vector_order.map { |v| (opts[:by] || {})[v] }
-        vector_locs = vector_order.map { |v| @vectors[v] }
+        vector_locs = vector_order.map { |v| sort_vector_position(v) }
 
         lambda do |index1, index2|
           # Build left and right array to compare two rows

data/lib/daru_lite/dataframe.rb

@@ -267,8 +267,12 @@ module DaruLite
     def delete_vector(vector)
       raise IndexError, "Vector #{vector} does not exist." unless @vectors.include?(vector)
 
-      @data.delete_at @vectors[vector]
-      @vectors = DaruLite::Index.new @vectors.to_a - [vector]
+      # Delete the first matching column by position: a MultiIndex with duplicate tuples resolves a
+      # name to several positions, and removing every duplicate name would desync @vectors from @data.
+      # Reuse the index's own #delete_at, which preserves the index type.
+      position = @vectors.is_a?(MultiIndex) ? @vectors.positions_for(vector).first : @vectors[vector]
+      @data.delete_at(position)
+      @vectors = @vectors.delete_at(position)
 
       self
     end
@@ -469,7 +473,9 @@ module DaruLite
         @size    == other.size    &&
         @index   == other.index   &&
         @vectors == other.vectors &&
-        @vectors.to_a.all? { |v| self[v] == other[v] }
+        # Compare columns by position: name-based access is ambiguous (and recurses infinitely)
+        # when the vectors are a MultiIndex with duplicate tuples.
+        @data    == other.data
     end
 
     # Converts the specified non category type vectors to category type vectors
@@ -589,7 +595,7 @@ module DaruLite
       end
 
       if pos.is_a?(DaruLite::Index)
-        assign_multiple_vectors pos, v
+        assign_multiple_vectors name, pos, v
       elsif pos == name &&
             (@vectors.include?(name) || (pos.is_a?(Integer) && pos < @data.size))
 
@@ -599,10 +605,14 @@ module DaruLite
       end
     end
 
-    def assign_multiple_vectors(pos, v)
-      pos.each do |p|
-        @data[@vectors[p]] = v
-      end
+    # Assign +v+ to every column matching +name+ (a partial key, or a full MultiIndex tuple that is
+    # duplicated across several positions). For a MultiIndex, resolve to positions directly: a
+    # duplicated tuple re-looked-up by name would return a MultiIndex instead of an integer.
+    def assign_multiple_vectors(name, pos, v)
+      positions = @vectors.is_a?(MultiIndex) ? @vectors.positions_for(name.flatten) : pos.map { |p| @vectors[p] }
+      # Give all but the first match an independent copy so duplicate columns don't share one
+      # Vector instance (a later cell mutation would otherwise leak across both).
+      positions.each_with_index { |position, i| @data[position] = i.zero? ? v : v.dup }
     end
 
     def assign_or_add_vector_rough(name, v)
@@ -764,11 +774,42 @@ module DaruLite
     end
 
     def initialize_from_array_of_vectors(source, vectors, index, opts)
+      # Build @data positionally rather than round-tripping through a name-keyed hash: duplicate
+      # MultiIndex tuples would collapse into a single hash entry and corrupt the columns.
+      @vectors = Index.coerce(vectors)
+
+      first_index = source.first.index
+      vectors_have_same_index = source.all? { |vector| first_index == vector.index }
+
       clone = opts[:clone] != false
-      hsh = vectors.each_with_index.to_h do |name, idx|
-        [name, source[idx]]
+      clone = true unless index || vectors_have_same_index
+
+      @index = deduce_index_from_vectors(index, source, first_index, vectors_have_same_index)
+
+      @data =
+        if !clone
+          source.dup
+        elsif vectors_have_same_index
+          source.map(&:dup)
+        else
+          source.map.with_index { |vector, position| reindex_vector(vector, @vectors.to_a[position]) }
+        end
+    end
+
+    def deduce_index_from_vectors(index, source, first_index, vectors_have_same_index)
+      if index
+        Index.coerce(index)
+      elsif vectors_have_same_index
+        first_index.dup
+      else
+        DaruLite::Index.new(source.map { |vector| vector.index.to_a }.flatten.uniq.sort)
+      end
+    end
+
+    def reindex_vector(vector, name)
+      DaruLite::Vector.new([], name: name, index: @index).tap do |new_vector|
+        @index.each { |idx| new_vector[idx] = vector.index.include?(idx) ? vector[idx] : nil }
       end
-      initialize(hsh, index: index, order: vectors, name: @name, clone: clone)
     end
 
     def initialize_from_array_of_hashes(source, vectors, index, _opts)

data/lib/daru_lite/index/categorical_index.rb

@@ -1,5 +1,9 @@
 module DaruLite
   class CategoricalIndex < Index
+    UNSUPPORTED_RANGE_MSG =
+      'CategoricalIndex does not support label-range slicing: ' \
+      'categories are unordered and may repeat'.freeze
+
     # Create a categorical index object.
     # @param indexes [Array<object>] array of indexes
     # @return [DaruLite::CategoricalIndex] categorical index
@@ -51,6 +55,10 @@ module DaruLite
     #   x.pos :a, 1
     #   # => [0, 1, 2, 3]
     def pos(*indexes)
+      if indexes.size == 1 && indexes.first.is_a?(Range) && !include?(indexes.first)
+        return pos_from_range(indexes.first)
+      end
+
       positions = indexes.map do |index|
         if include? index
           @cat_hash[index]
@@ -81,6 +89,35 @@ module DaruLite
       nil
     end
 
+    # Returns the category located at a positional value.
+    # Mirrors Index#key but reads the categorical structure instead of @keys,
+    # which CategoricalIndex never populates.
+    # @param value [Integer] positional value
+    # @return [object, nil] category at the position, or nil if out of range
+    # @example
+    #   idx = DaruLite::CategoricalIndex.new [:a, :b, :a]
+    #   idx.key 1   # => :b
+    #   idx.key 99  # => nil
+    def key(value)
+      return nil unless value.is_a?(Numeric)
+
+      to_a[value]
+    end
+
+    # Label-range slicing is not supported: categories are unordered and may
+    # repeat, so a range of positions between two labels is ambiguous.
+    # @raise [ArgumentError] always
+    def slice(*)
+      raise ArgumentError, UNSUPPORTED_RANGE_MSG
+    end
+
+    # Label-range slicing is not supported: categories are unordered and may
+    # repeat, so a range of positions between two labels is ambiguous.
+    # @raise [ArgumentError] always
+    def subset_slice(*)
+      raise ArgumentError, UNSUPPORTED_RANGE_MSG
+    end
+
     # Returns index value from position
     # @param pos [Integer] the position to look for
     # @return [object] category corresponding to position
@@ -206,6 +243,31 @@ module DaruLite
 
     private
 
+    # Single-key position lookup, resolved against the categorical structure.
+    # Overrides Index#numeric_pos, which reads the never-populated @relation_hash.
+    # @raise [IndexError] when the key is neither a valid category nor position
+    def numeric_pos(key)
+      pos(key)
+    end
+
+    # Label-range slicing is not supported (see #slice / #subset_slice).
+    # @raise [ArgumentError] always
+    def preprocess_range(_rng)
+      raise ArgumentError, UNSUPPORTED_RANGE_MSG
+    end
+
+    # A positional (integer) range resolves to the positions it spans, mirroring
+    # pandas iloc / Vector#head / #tail. A non-integer label range is rejected
+    # because categories are unordered and may repeat (like pandas .loc on an
+    # unordered CategoricalIndex).
+    # @raise [ArgumentError] when the range bounds are not integers
+    def pos_from_range(rng)
+      raise ArgumentError, UNSUPPORTED_RANGE_MSG unless rng.begin.is_a?(Integer) && rng.end.is_a?(Integer)
+
+      # size.times.to_a[rng] clamps to valid positions; nil (fully out of range) -> []
+      size.times.to_a[rng] || []
+    end
+
     def int_from_cat(cat)
       @cat_hash.keys.index cat
     end

data/lib/daru_lite/index/multi_index.rb

@@ -227,22 +227,40 @@ module DaruLite
       collection.one? ? collection.first : collection
     end
 
-    def retrieve_from_tuple(key)
+    # Return every integer position whose tuple matches the (possibly partial) key.
+    # Unlike #retrieve_from_tuple, the return type is always an Array of positions,
+    # even when a full tuple is duplicated across several positions.
+    #
+    # @param key [Array] a full or left-anchored partial tuple
+    # @return [Array<Integer>] matching positions, in ascending order
+    def positions_for(key)
       chosen = []
 
       key.each_with_index do |k, depth|
-        level_index = @levels[depth][k]
+        # An over-long key runs past the defined levels; guard explicitly rather than letting
+        # nil[k] raise NoMethodError.
+        level = @levels[depth]
+        raise IndexError, "Specified index #{key.inspect} do not exist" if level.nil?
+
+        level_index = level[k]
         raise IndexError, "Specified index #{key.inspect} do not exist" if level_index.nil?
 
-        label = @labels[depth]
-        chosen = find_all_indexes label, level_index, chosen
+        chosen = find_all_indexes(@labels[depth], level_index, chosen)
       end
 
+      chosen
+    end
+
+    def retrieve_from_tuple(key)
+      chosen = positions_for(key)
+
+      # Every level component existed individually but no tuple matches the full combination
+      # (e.g. [:a, :two, :foo] when that triple was never indexed together).
+      raise IndexError, "Specified index #{key.inspect} do not exist" if chosen.empty?
+
       return chosen[0] if chosen.size == 1 && key.size == @levels.size
 
       multi_index_from_multiple_selections(chosen)
-    rescue NoMethodError
-      raise IndexError, "Specified index #{key.inspect} do not exist"
     end
 
     def multi_index_from_multiple_selections(chosen)

data/lib/daru_lite/maths/statistics/dataframe.rb

@@ -166,7 +166,9 @@ module DaruLite
         private
 
         def apply_method_to_numerics(method, *)
-          numerics = @vectors.to_a.map { |n| [n, @data[@vectors[n]]] }.select { |_n, v| v.numeric? }
+          numerics = @data.each_with_index
+                          .map { |v, position| [@vectors.to_a[position], v] }
+                          .select { |_n, v| v.numeric? }
           computed = numerics.map { |_n, v| v.send(method, *) }
 
           DaruLite::DataFrame.new(computed, index: @index, order: numerics.map(&:first), clone: false)
@@ -187,10 +189,12 @@ module DaruLite
         end
 
         def compute_stats(method)
-          DaruLite::Vector.new(
-            numeric_vectors.to_h { [it, self[it].send(method)] },
-            name: method
-          )
+          # Iterate by position (via each_vector_with_index) instead of `self[name]`: a MultiIndex
+          # with duplicate tuples would make the name lookup ambiguous and collapse the result.
+          stats = each_vector_with_index.select { |vector, _name| vector.numeric? }
+                                        .map { |vector, name| [name, vector.send(method)] }
+
+          DaruLite::Vector.new(stats.map(&:last), index: stats.map(&:first), name: method)
         end
         alias sds std
         alias variance variance_sample

data/lib/daru_lite/version.rb

@@ -1,3 +1,3 @@
 module DaruLite
-  VERSION = '0.3.3'.freeze
+  VERSION = '0.3.4'.freeze
 end

data/spec/category_spec.rb

@@ -1189,6 +1189,32 @@ describe DaruLite::Vector, "categorical" do
     end
   end
 
+  context "positional slicing on a CategoricalIndex-backed Vector" do
+    let(:dv) do
+      DaruLite::Vector.new(
+        [10, 20, 30, 40, 50],
+        index: DaruLite::CategoricalIndex.new([:a, :b, :a, :a, :c])
+      )
+    end
+
+    context "#head" do
+      it { expect(dv.head(2).to_a).to eq [10, 20] }
+      it { expect(dv.head(99).to_a).to eq [10, 20, 30, 40, 50] }
+    end
+
+    context "#tail" do
+      it { expect(dv.tail(2).to_a).to eq [40, 50] }
+    end
+
+    context "#last" do
+      it { expect(dv.last(2).to_a).to eq [40, 50] }
+    end
+
+    context "positional range" do
+      it { expect(dv[0..2].to_a).to eq [10, 20, 30] }
+    end
+  end
+
   context "#set_at" do
     context DaruLite::Index do
       let (:idx) { DaruLite::Index.new [1, 0, :c] }

data/spec/data_frame/duplicatable_example.rb

@@ -23,6 +23,29 @@ shared_examples_for 'a duplicatable DataFrame' do
         expect(subject.vectors.object_id).not_to eq(df_mi.vectors.object_id)
         expect(subject.index.object_id).not_to eq(df_mi.index.object_id)
       end
+
+      context "with duplicate tuples" do
+        let(:dup_df) do
+          DaruLite::DataFrame.new(
+            [[1, 2], [3, 4], [5, 6], [7, 8]],
+            order: DaruLite::MultiIndex.from_tuples([
+              [:weighted_count, 'Wave'], [:weighted_count, 'Wave'],
+              [:percentage, 'Wave'], [:percentage, 'Wave']
+            ]),
+            index: %w[Yes No]
+          )
+        end
+
+        it "dups without corrupting the columns and preserves the MultiIndex" do
+          copy = dup_df.dup
+
+          expect(copy).to eq(dup_df)
+          expect(copy.vectors).to be_a(DaruLite::MultiIndex)
+          expect(copy.vectors).to eq(dup_df.vectors)
+          expect(copy.data.map(&:to_a)).to eq([[1, 2], [3, 4], [5, 6], [7, 8]])
+          expect(copy.vectors.object_id).not_to eq(dup_df.vectors.object_id)
+        end
+      end
     end
   end
 

data/spec/data_frame/fetchable_example.rb

@@ -79,6 +79,35 @@ shared_examples_for 'a fetchable DataFrame' do
         )
       end
     end
+
+    context "with duplicate tuples in a MultiIndex" do
+      let(:dup_df) do
+        DaruLite::DataFrame.new(
+          [[1, 2], [3, 4], [5, 6], [7, 8]],
+          order: DaruLite::MultiIndex.from_tuples([
+            [:weighted_count, 'Wave'], [:weighted_count, 'Wave'],
+            [:percentage, 'Wave'], [:percentage, 'Wave']
+          ]),
+          index: %w[Yes No]
+        )
+      end
+
+      it "returns a DataFrame with all matching columns for a partial key" do
+        result = dup_df[:weighted_count]
+
+        expect(result).to be_a(DaruLite::DataFrame)
+        expect(result.ncols).to eq(2)
+        expect(result.map_vectors(&:to_a)).to eq([[1, 2], [3, 4]])
+        expect(result.index).to eq(dup_df.index)
+      end
+
+      it "returns a DataFrame with all matching columns for a duplicate full tuple" do
+        result = dup_df[:weighted_count, 'Wave']
+
+        expect(result).to be_a(DaruLite::DataFrame)
+        expect(result.map_vectors(&:to_a)).to eq([[1, 2], [3, 4]])
+      end
+    end
   end
 
   describe "#at" do

data/spec/data_frame/iterable_example.rb

@@ -25,6 +25,22 @@ shared_examples_for 'an iterable DataFrame' do
 
       expect(ret).to eq(df)
     end
+
+    it "iterates over vectors of a MultiIndex with duplicate tuples" do
+      order = DaruLite::MultiIndex.from_tuples([
+        [:weighted_count, 'Wave'], [:weighted_count, 'Wave'],
+        [:percentage, 'Wave'], [:percentage, 'Wave']
+      ])
+      dup_df = DaruLite::DataFrame.new([[1, 2], [3, 4], [5, 6], [7, 8]], order: order, index: %w[Yes No])
+
+      tuples = []
+      dup_df.each_vector_with_index do |vector, index|
+        tuples << index
+        expect(vector).to be_a(DaruLite::Vector)
+      end
+
+      expect(tuples).to eq(order.to_a)
+    end
   end
 
   describe "#each_row_with_index" do

data/spec/data_frame/setable_example.rb

@@ -221,6 +221,37 @@ shared_examples_for 'a setable DataFrame' do
 
         expect(df_empty[:c, :one, :bar].name).to eq "conebar"
       end
+
+      context "with duplicate tuples" do
+        let(:dup_df) do
+          DaruLite::DataFrame.new(
+            [[1, 2], [3, 4], [5, 6], [7, 8]],
+            order: DaruLite::MultiIndex.from_tuples([
+              [:weighted_count, 'Wave'], [:weighted_count, 'Wave'],
+              [:percentage, 'Wave'], [:percentage, 'Wave']
+            ]),
+            index: %w[Yes No]
+          )
+        end
+
+        it "assigns every column matching a duplicate full tuple" do
+          dup_df[:weighted_count, 'Wave'] = [10, 20]
+
+          expect(dup_df.data.map(&:to_a)).to eq([[10, 20], [10, 20], [5, 6], [7, 8]])
+        end
+
+        it "assigns independent Vector instances to duplicate columns" do
+          dup_df[:weighted_count, 'Wave'] = [10, 20]
+
+          expect(dup_df.data[0].object_id).not_to eq(dup_df.data[1].object_id)
+        end
+
+        it "assigns every column matching a partial key" do
+          dup_df[:percentage] = [99, 98]
+
+          expect(dup_df.data.map(&:to_a)).to eq([[1, 2], [3, 4], [99, 98], [99, 98]])
+        end
+      end
     end
   end
 

data/spec/data_frame/sortable_example.rb

@@ -240,7 +240,25 @@ shared_examples_for 'a sortable DataFrame' do
     end
 
     context DaruLite::MultiIndex do
-      pending
+      context "with duplicate tuples" do
+        let(:dup_df) do
+          DaruLite::DataFrame.new(
+            [[1, 2], [3, 4], [5, 6], [7, 8]],
+            order: DaruLite::MultiIndex.from_tuples([
+              [:weighted_count, 'Wave'], [:weighted_count, 'Wave'],
+              [:percentage, 'Wave'], [:percentage, 'Wave']
+            ]),
+            index: %w[Yes No]
+          )
+        end
+
+        it "sorts by a duplicated vector without raising" do
+          sorted = dup_df.sort([[:percentage, 'Wave']], ascending: [false])
+
+          expect(sorted.index.to_a).to eq(%w[No Yes])
+          expect(sorted.data.map(&:to_a)).to eq([[2, 1], [4, 3], [6, 5], [8, 7]])
+        end
+      end
     end
 
     context DaruLite::CategoricalIndex do

data/spec/dataframe_spec.rb

@@ -148,6 +148,18 @@ describe DaruLite::DataFrame do
         expect(df.a)      .to eq(DaruLite::Vector.new([2]*5))
       end
 
+      it "names the reindexed vectors after their order labels when indexes differ" do
+        df = DaruLite::DataFrame.new(
+          [
+            DaruLite::Vector.new([1, 2], index: [:one, :two]),
+            DaruLite::Vector.new([3, 4], index: [:two, :three])
+          ],
+          order: [:b, :a]
+        )
+
+        expect(df.data.map(&:name)).to eq([:b, :a])
+      end
+
       it "accepts Index objects for row/col" do
         rows = DaruLite::Index.new [:one, :two, :three, :four, :five]
         cols = DaruLite::Index.new [:a, :b]
@@ -865,6 +877,30 @@ describe DaruLite::DataFrame do
                 index: [:one, :two, :three, :four, :five]))
       end
     end
+
+    context "with duplicate tuples in a MultiIndex" do
+      let(:dup_df) do
+        DaruLite::DataFrame.new(
+          [[1, 2], [3, 4], [5, 6], [7, 8]],
+          order: DaruLite::MultiIndex.from_tuples([
+            [:weighted_count, 'Wave'], [:weighted_count, 'Wave'],
+            [:percentage, 'Wave'], [:percentage, 'Wave']
+          ]),
+          index: %w[Yes No]
+        )
+      end
+
+      it "deletes the first matching column, leaving the other in place" do
+        dup_df.delete_vector([:weighted_count, 'Wave'])
+
+        expect(dup_df.ncols).to eq(3)
+        expect(dup_df.vectors).to be_a(DaruLite::MultiIndex)
+        expect(dup_df.vectors.to_a).to eq([
+          [:weighted_count, 'Wave'], [:percentage, 'Wave'], [:percentage, 'Wave']
+        ])
+        expect(dup_df.data.map(&:to_a)).to eq([[3, 4], [5, 6], [7, 8]])
+      end
+    end
   end
 
   context "#delete_vectors" do

data/spec/index/categorical_index_spec.rb

@@ -32,6 +32,24 @@ describe DaruLite::CategoricalIndex do
         it { expect { index.pos :e }.to raise_error IndexError }
       end
 
+      context "label range argument" do
+        it { expect { index.pos :a..:c }.to raise_error ArgumentError }
+      end
+
+      context "positional (integer) range argument" do
+        it { expect(index.pos(0..2)).to eq [0, 1, 2] }
+
+        context "when the range extends past the end" do
+          it { expect(index.pos(0..99)).to eq [0, 1, 2, 3, 4] }
+        end
+      end
+
+      context "when a category is itself a Range" do
+        let(:index) { described_class.new [(1..2), (3..4), (1..2)] }
+
+        it { expect(index.pos(1..2)).to eq [0, 2] }
+      end
+
       context "positional index" do
         it { expect(index.pos 0).to eq 0 }
       end
@@ -98,6 +116,56 @@ describe DaruLite::CategoricalIndex do
 
       it { is_expected.to be_nil }
     end
+
+    context "when given a label range" do
+      it { expect { index[:a..:c] }.to raise_error ArgumentError }
+    end
+
+    context "when given a positional (integer) range" do
+      subject { index[0..2] }
+
+      it { is_expected.to eq [0, 1, 2] }
+    end
+
+    context "when a category is itself a Range" do
+      let(:index) { described_class.new [(1..2), (3..4), (1..2)] }
+
+      it { expect(index[1..2]).to eq [0, 2] }
+    end
+  end
+
+  describe "#key" do
+    context "when given a position" do
+      subject { index.key(1) }
+
+      it { is_expected.to eq :b }
+    end
+
+    context "when the position holds a duplicated category" do
+      subject { index.key(3) }
+
+      it { is_expected.to eq :a }
+    end
+
+    context "when the position is out of range" do
+      subject { index.key(99) }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "when given a non-numeric value" do
+      subject { index.key(:a) }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe "#slice" do
+    it { expect { index.slice(:a, :c) }.to raise_error ArgumentError }
+  end
+
+  describe "#subset_slice" do
+    it { expect { index.subset_slice(:a, :c) }.to raise_error ArgumentError }
   end
 
   context "#subset" do

data/spec/index/multi_index_spec.rb

@@ -542,6 +542,45 @@ describe DaruLite::MultiIndex do
     # TODO: Add specs for IndexError
   end
 
+  context "#positions_for" do
+    let(:idx) do
+      described_class.from_tuples([
+        [:b, :one, :bar],
+        [:b, :two, :bar],
+        [:b, :two, :baz],
+        [:b, :one, :foo]
+      ])
+    end
+
+    it "returns all matching positions for a partial key" do
+      expect(idx.positions_for([:b, :one])).to eq([0, 3])
+    end
+
+    it "returns a single-element array for a full unique tuple" do
+      expect(idx.positions_for([:b, :one, :bar])).to eq([0])
+    end
+
+    it "returns every position for duplicate tuples" do
+      dup_idx = described_class.from_tuples([
+        [:weighted_count, 'Wave'],
+        [:weighted_count, 'Wave'],
+        [:percentage, 'Wave'],
+        [:percentage, 'Wave']
+      ])
+
+      expect(dup_idx.positions_for([:weighted_count, 'Wave'])).to eq([0, 1])
+      expect(dup_idx.positions_for([:weighted_count])).to eq([0, 1])
+    end
+
+    it "raises IndexError for a non-existent key" do
+      expect { idx.positions_for([:z]) }.to raise_error(IndexError)
+    end
+
+    it "raises IndexError (not NoMethodError) for a key longer than the levels" do
+      expect { idx.positions_for([:b, :one, :bar, :extra]) }.to raise_error(IndexError)
+    end
+  end
+
   context "#subset" do
     let(:idx) do
       described_class.from_tuples([

data/spec/maths/statistics/dataframe_spec.rb

@@ -20,6 +20,19 @@ describe DaruLite::DataFrame do
     it "calculates mean of multi level numeric only vectors and returns values in a DataFrame" do
       # TODO - pending
     end
+
+    it "calculates mean of a MultiIndex with duplicate tuples without raising" do
+      dup_df = DaruLite::DataFrame.new(
+        [[1, 3], [2, 4], [5, 7], [6, 8]],
+        order: DaruLite::MultiIndex.from_tuples([
+          [:weighted_count, 'Wave'], [:weighted_count, 'Wave'],
+          [:percentage, 'Wave'], [:percentage, 'Wave']
+        ]),
+        index: %w[Yes No]
+      )
+
+      expect(dup_df.mean.to_a).to eq([2.0, 3.0, 6.0, 7.0])
+    end
   end
 
   context "#variance_sample" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daru_lite
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Thomas Naude-Filonnière
@@ -550,7 +550,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Data Analysis in RUby, stripped down
 test_files: