Refactor indexing

lib/daru/index.rb

@@ -81,7 +81,13 @@ def [](*key)
 
         slice first, last
       when key.size > 1
-        Daru::Index.new key.map { |k| self[k] }
+        if include? key[0]
+          Daru::Index.new key.map { |k| k }
+        else
+          # Assume the user is specifing values for index not keys
+          # Return index object having keys corresponding to values provided
+          Daru::Index.new key.map { |k| key k }
+        end
       else
         v = @relation_hash[loc]
         return loc if v.nil?
@@ -143,6 +149,14 @@ def self._load data
 
       Daru::Index.new(h[:relation_hash].keys)
     end
+
+    # Provide an Index for sub vector produced
+    #
+    # @param input_indexes [Array] the input by user to index the vector
+    # @return [Object] the Index object for sub vector produced
+    def conform input_indexes
+      self
+    end
   end # class Index
 
   class MultiIndex < Index
@@ -214,7 +228,7 @@ def [] *key
       case
       when key[0].is_a?(Range) then retrieve_from_range(key[0])
       when (key[0].is_a?(Integer) and key.size == 1) then try_retrieve_from_integer(key[0])
-      else retrieve_from_tuples(key)
+      else retrieve_from_tuples key
       end
     end
 
@@ -236,7 +250,7 @@ def retrieve_from_tuples key
         chosen = find_all_indexes label, level_index, chosen
       end
 
-      return chosen[0] if chosen.size == 1
+      return chosen[0] if chosen.size == 1 and key.size == @levels.size
       return multi_index_from_multiple_selections(chosen)              
     end
 
@@ -330,5 +344,14 @@ def values
     def inspect
       "Daru::MultiIndex:#{self.object_id} (levels: #{levels}\nlabels: #{labels})"
     end
+
+    # Provide a MultiIndex for sub vector produced
+    #
+    # @param input_indexes [Array] the input by user to index the vector
+    # @return [Object] the MultiIndex object for sub vector produced
+    def conform input_indexes
+      return self if input_indexes[0].is_a? Range
+      drop_left_level input_indexes.size
+    end
   end
 end

lib/daru/vector.rb

@@ -199,56 +199,19 @@ def self.[](*args)
     #
     #   # For vectors employing hierarchial multi index
     #
-    def [](*indexes)
-      location = indexes[0]
-      if @index.is_a?(MultiIndex)
-        sub_index = @index[indexes]
-        result =
-        if sub_index.is_a?(Integer)
-          @data[sub_index]
-        else
-          elements = sub_index.map do |tuple|
-            @data[@index[tuple]]
-          end
-
-          if !indexes[0].is_a?(Range) and indexes.size < @index.width
-            sub_index = sub_index.drop_left_level indexes.size
-          end
-          Daru::Vector.new(
-            elements, index: sub_index, name: @name, dtype: @dtype)
-        end
-
-        return result
-      else
-        raise TypeError, "Invalid index type #{location.inspect}.\
-          \nUsage: v[:a, :b] gives elements with keys :a and :b for vector v." if location.is_a? Array
-
-        unless indexes[1]
-          case location
-          when Range
-            first = location.first
-            last  = location.last
-            indexes = @index.slice first, last
-          else
-            pos = @index[location]
-            if pos.is_a?(Numeric)
-              return @data[pos]
-            else
-              indexes = pos
-            end
-          end
-        else
-          indexes = indexes.map { |e| named_index_for(e) }
-        end
+    def [](*input_indexes)
+      # Get a proper index object
+      indexes = @index[*input_indexes]
 
-        begin
-          Daru::Vector.new(
-            indexes.map { |loc| @data[@index[loc]] },
-            name: @name, index: indexes, dtype: @dtype)
-        rescue NoMethodError
-          raise IndexError, "Specified index #{pos.inspect} does not exist."
-        end
+      # If one object is asked return it
+      if indexes.is_a? Numeric
+        return @data[indexes]
       end
+
+      # Form a new Vector using indexes and return it
+      Daru::Vector.new(
+        indexes.map { |loc| @data[@index[loc]] },
+        name: @name, index: indexes.conform(input_indexes), dtype: @dtype)
     end
 
     # Just like in Hashes, you can specify the index label of the Daru::Vector
@@ -1311,16 +1274,6 @@ def cast_vector_to dtype, source=nil, nm_dtype=nil
       new_vector
     end
 
-    def named_index_for index
-      if @index.include? index
-        index
-      elsif @index.key index
-        @index.key index
-      else
-        raise IndexError, "Specified index #{index} does not exist."
-      end
-    end
-
     def index_for index
       if @index.include?(index)
         @index[index]

spec/dataframe_spec.rb

@@ -455,7 +455,7 @@
       end
 
       it "returns a Vector if the last level of MultiIndex is tracked" do
-        expect(@df_mi[:a, :one]).to eq(
+        expect(@df_mi[:a, :one, :bar]).to eq(
           Daru::Vector.new(@vector_arry1, index: @multi_index))
       end
     end

spec/index_spec.rb

@@ -76,7 +76,7 @@
   context "#[]" do
     before do
       @id = Daru::Index.new [:one, :two, :three, :four, :five, :six, :seven]
-      @mixed_id = Daru::Index.new ['a','b','c',:d,:a,0,3,5]
+      @mixed_id = Daru::Index.new ['a','b','c',:d,:a,8,3,5]
     end
 
     it "works with ranges" do
@@ -88,12 +88,12 @@
       expect(@mixed_id[0..2]).to eq(Daru::Index.new(['a','b','c']))
 
       # If atleast one is a number then refer to actual indexing
-      expect(@mixed_id.slice('b',0)).to eq(Daru::Index.new(['b','c',:d,:a,0]))
+      expect(@mixed_id.slice('b',8)).to eq(Daru::Index.new(['b','c',:d,:a,8]))
     end
 
     it "returns multiple keys if specified multiple indices" do
-      expect(@id[0,1,3,4]).to eq(Daru::Index.new([0,1,3,4]))
-      expect(@mixed_id[0,5,3,2]).to eq(Daru::Index.new([5, 7, 6, 2]))
+      expect(@id[0,1,3,4]).to eq(Daru::Index.new([:one, :two, :four, :five]))
+      expect(@mixed_id[0,5,3,2]).to eq(Daru::Index.new(['a', 8, :d, 'c']))
     end
 
     it "returns correct index position for non-numeric index" do
@@ -102,7 +102,7 @@
     end
 
     it "returns correct index position for mixed index" do
-      expect(@mixed_id[0]).to eq(5)
+      expect(@mixed_id[8]).to eq(5)
       expect(@mixed_id['c']).to eq(2)
     end
   end

spec/vector_spec.rb

@@ -177,11 +177,12 @@
               [:c,:one,:bar],
               [:c,:one,:baz],
               [:c,:two,:foo],
-              [:c,:two,:bar]
+              [:c,:two,:bar],
+              [:d,:one,:foo]
             ]
             @multi_index = Daru::MultiIndex.from_tuples(@tuples)
             @vector = Daru::Vector.new(
-              Array.new(12) { |i| i }, index: @multi_index,
+              Array.new(13) { |i| i }, index: @multi_index,
               dtype: dtype, name: :mi_vector)
           end
 
@@ -211,6 +212,12 @@
               dtype: dtype, name: :sub_sub_vector))
           end
 
+          it "returns sub vector not a single element when passed the partial tuple" do
+            mi = Daru::MultiIndex.from_tuples([[:foo]])
+            expect(@vector[:d, :one]).to eq(Daru::Vector.new([12], index: mi,
+              dtype: dtype, name: :sub_sub_vector))
+          end
+
           it "returns a vector with corresponding MultiIndex when specified numeric Range" do
             mi = Daru::MultiIndex.from_tuples([
               [:a,:two,:baz],