daru 0.1.5 → 0.3

data/benchmarks/db_loading.rb

@@ -0,0 +1,34 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru'
+require 'sqlite3'
+require 'dbi'
+require 'active_record'
+
+db_name = 'daru_test.sqlite'
+FileUtils.rm(db_name) if File.file?(db_name)
+
+SQLite3::Database.new(db_name).tap do |db|
+  db.execute "create table accounts(id integer, name varchar, age integer, primary key(id))"
+
+  values = 1.upto(100_000).map { |i| %!(#{i},"name_#{i}",#{rand(100)})! }.join(",")
+  db.execute "insert into accounts values #{values}"
+end
+
+ActiveRecord::Base.establish_connection("sqlite3:#{db_name}")
+ActiveRecord::Base.connection
+
+class Account < ActiveRecord::Base; end
+
+Benchmark.bm do |x|
+  x.report("DataFrame.from_sql") do
+    Daru::DataFrame.from_sql(ActiveRecord::Base.connection, "SELECT * FROM accounts")
+  end
+
+  x.report("DataFrame.from_activerecord") do
+    Daru::DataFrame.from_activerecord(Account.all)
+  end
+end
+
+FileUtils.rm(db_name)

data/benchmarks/statistics.rb

@@ -5,26 +5,26 @@ vector = Daru::Vector.new(
   (10**6).times.map.to_a.shuffle,
   missing_values: 100.times.map.to_a.shuffle
   )
-  
+
 vector_gsl = Daru::Vector.new(
   10000.times.map.to_a.shuffle,
   missing_values: 100.times.map.to_a.shuffle,
   dtype: :gsl
-  )  
-  
+  )
+
 Benchmark.bm do |x|
   x.report("Mean of a vector") do
     vector.mean
   end
-  
+
   x.report("Minimum of a vector") do
     vector.min
   end
-  
+
   x.report("Mean of a vector with data type gsl") do
     vector_gsl.mean
   end
-  
+
   x.report "Minimum of a vector with data type gsl" do
     vector_gsl.min
   end

data/benchmarks/where_clause.rb

@@ -35,7 +35,7 @@ Benchmark.bm do |x|
 end
 
 #                     ====== Benchmarks ======
-# 
+#
 # Benchmarking DataFrame#where
 #
 #                             user     system      total      real

data/benchmarks/where_vs_filter.rb

@@ -22,7 +22,7 @@ Benchmark.bm do |x|
 end
 
 #             ===== Benchmarks =====
-# 
+#
 #                user     system      total        real
 # where        0.000000   0.000000   0.000000 (  0.002575)
 # filter_rows  0.210000   0.000000   0.210000 (  0.205403)

data/daru.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['sameer.deshmukh93@gmail.com']
   spec.summary       = %q{Data Analysis in RUby}
   spec.description   = Daru::DESCRIPTION
-  spec.homepage      = "http://github.com/v0dro/daru"
+  spec.homepage      = "http://github.com/SciRuby/daru"
   spec.license       = 'BSD-2'
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -27,35 +27,12 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.post_install_message = <<-EOF
-*************************************************************************
-Thank you for installing daru!
+  # it is required by NMatrix, yet we want to specify clearly which minimal version is OK
+  spec.add_runtime_dependency 'packable', '~> 1.3.13'
 
-  oOOOOOo
- ,|    oO
-//|     |
-\\\\|     |
- `|     |
-  `-----`
-
-
-Hope you love daru! For enhanced interactivity and better visualizations,
-consider using gnuplotrb and nyaplot with iruby. For statistics use the
-statsample family.
-
-Read the README for interesting use cases and examples.
-
-Cheers!
-*************************************************************************
-EOF
-
-
-  spec.add_runtime_dependency 'backports'
-
-  spec.add_development_dependency 'reportbuilder', '~> 1.4'
   spec.add_development_dependency 'spreadsheet', '~> 1.1.1'
-  spec.add_development_dependency 'bundler', '~> 1.10'
-  spec.add_development_dependency 'rake', '~>10.5'
+  spec.add_development_dependency 'bundler', '>= 1.10'
+  spec.add_development_dependency 'rake', '~>13.0'
   spec.add_development_dependency 'pry', '~> 0.10'
   spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'rserve-client', '~> 0.3'
@@ -63,23 +40,22 @@ EOF
   spec.add_development_dependency 'rspec-its'
   spec.add_development_dependency 'awesome_print'
   spec.add_development_dependency 'nyaplot', '~> 0.1.5'
-  spec.add_development_dependency 'nmatrix', '~> 0.2.1'
+  spec.add_development_dependency 'nmatrix', '~> 0.2.1' if ENV['DARU_TEST_NMATRIX']
   spec.add_development_dependency 'distribution', '~> 0.7'
-  spec.add_development_dependency 'gsl', '~>2.1.0.2'
+  spec.add_development_dependency 'gsl', '~>2.1.0.2' if ENV['DARU_TEST_GSL']
   spec.add_development_dependency 'dbd-sqlite3'
   spec.add_development_dependency 'dbi'
-  spec.add_development_dependency 'activerecord', '~> 4.0'
-  spec.add_development_dependency 'sqlite3'
-  spec.add_development_dependency 'rubocop', '>= 0.40.0'
+  spec.add_development_dependency 'activerecord', '~> 6.0'
+  spec.add_development_dependency 'mechanize'
+  # issue : https://github.com/SciRuby/daru/issues/493 occured 
+  # with latest version of sqlite3
+  spec.add_development_dependency  'sqlite3'
+  spec.add_development_dependency 'rubocop', '~> 0.49.0'
   spec.add_development_dependency 'ruby-prof'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'gruff'
-  if RUBY_VERSION < '2.1.0'
-    spec.add_development_dependency 'nokogiri', '<= 1.6.8.1'
-  else
-    spec.add_development_dependency 'nokogiri'
-  end
-  if RUBY_VERSION >= '2.2.5'
-    spec.add_development_dependency 'guard-rspec'
-  end
+  spec.add_development_dependency 'webmock'
+
+  spec.add_development_dependency 'nokogiri'
+  spec.add_development_dependency 'guard-rspec'
 end

data/lib/daru.rb

@@ -38,11 +38,13 @@ module Daru
 
   @plotting_library = :nyaplot
 
+  @error_stream = $stderr
+
   class << self
     # A variable which will set whether Vector metadata is updated immediately or lazily.
     # Call the #update method every time a values are set or removed in order to update
     # metadata like positions of missing values.
-    attr_accessor :lazy_update
+    attr_accessor :lazy_update, :error_stream
     attr_reader :plotting_library
 
     def create_has_library(library)
@@ -72,6 +74,10 @@ module Daru
         raise ArgumentError, "Unsupported library #{lib}"
       end
     end
+
+    def error msg
+      error_stream.puts msg if error_stream
+    end
   end
 
   create_has_library :gsl
@@ -80,16 +86,6 @@ module Daru
   create_has_library :gruff
 end
 
-[['reportbuilder', '~>1.4'], ['spreadsheet', '~>1.1.1']].each do |lib|
-  begin
-    gem lib[0], lib[1]
-    require lib[0]
-  rescue LoadError
-    STDERR.puts "\nInstall the #{lib[0]} gem version #{lib[1]} for using"\
-    " #{lib[0]} functions."
-  end
-end
-
 autoload :CSV, 'csv'
 require 'matrix'
 require 'forwardable'
@@ -98,11 +94,14 @@ require 'date'
 
 require 'daru/version.rb'
 
+require 'open-uri'
+
 require 'daru/index/index.rb'
 require 'daru/index/multi_index.rb'
 require 'daru/index/categorical_index.rb'
 
 require 'daru/helpers/array.rb'
+require 'daru/configuration.rb'
 require 'daru/vector.rb'
 require 'daru/dataframe.rb'
 require 'daru/monkeys.rb'
@@ -116,5 +115,3 @@ require 'daru/core/merge.rb'
 
 require 'daru/date_time/offsets.rb'
 require 'daru/date_time/index.rb'
-
-require 'backports'

data/lib/daru/accessors/gsl_wrapper.rb

@@ -65,7 +65,7 @@ if Daru.has_gsl?
           ::GSL::Vector.alloc(@data.to_a - [Float::NAN])
         end
 
-        [:mean, :min, :max, :prod, :sum].each do |method|
+        %i[mean min max prod sum].each do |method|
           define_method(method) do
             compact.send(method.to_sym) rescue nil
           end

data/lib/daru/accessors/nmatrix_wrapper.rb

@@ -25,6 +25,8 @@ if Daru.has_nmatrix?
         attr_reader :size, :data, :nm_dtype
 
         def initialize vector, context, nm_dtype=:int32
+          # To avoid arrays with nils throwing TypeError for nil nm_dtype
+          nm_dtype = :object if nm_dtype.nil? && vector.any?(&:nil?)
           @size = vector.size
           @data = NMatrix.new [@size*2], vector.to_a, dtype: nm_dtype
           @context = context

data/lib/daru/category.rb

@@ -1,5 +1,7 @@
 module Daru
   module Category # rubocop:disable Metrics/ModuleLength
+    UNDEFINED = Object.new.freeze
+
     attr_accessor :base_category
     attr_reader :index, :coding_scheme, :name
 
@@ -72,6 +74,13 @@ module Daru
       end
     end
 
+    # this method is overwritten: see Daru::Category#plotting_library=
+    def plot(*args, **options, &b)
+      init_plotting_library
+
+      plot(*args, **options, &b)
+    end
+
     alias_method :rename, :name=
 
     # Returns an enumerator that enumerates on categorical data
@@ -113,7 +122,7 @@ module Daru
     end
 
     # Associates a category to the vector.
-    # @param [Array] *new_categories new categories to be associated
+    # @param [Array] new_categories new categories to be associated
     # @example
     #   dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
     #   dv.add_category :b
@@ -131,7 +140,10 @@ module Daru
     #   dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
     #   dv.count :a
     #   # => 2
-    def count category
+    #   dv.count
+    #   # => 5
+    def count category=UNDEFINED
+      return @cat_hash.values.map(&:size).inject(&:+) if category == UNDEFINED # count all
       raise ArgumentError, "Invalid category #{category}" unless
         categories.include?(category)
 
@@ -167,9 +179,9 @@ module Daru
     end
 
     # Returns vector for indexes/positions specified
-    # @param [Array] *indexes indexes/positions for which values has to be retrived
+    # @param [Array] indexes for which values has to be retrived
     # @note Since it accepts both indexes and postions. In case of collision,
-    #   arguement will be treated as index
+    #   argument will be treated as index
     # @return vector containing values specified at specified indexes/positions
     # @example
     #   dv = Daru::Vector.new [:a, 1, :a, 1, :c],
@@ -196,7 +208,7 @@ module Daru
     end
 
     # Returns vector for positions specified.
-    # @param [Array] *positions positions at which values to be retrived.
+    # @param [Array] positions at which values to be retrived.
     # @return vector containing values specified at specified positions
     # @example
     #   dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
@@ -223,7 +235,7 @@ module Daru
 
     # Modifies values at specified indexes/positions.
     # @note In order to add a new category you need to associate it via #add_category
-    # @param [Array] *indexes indexes/positions at which to modify value
+    # @param [Array] indexes at which to modify value
     # @param [object] val value to assign at specific indexes/positions
     # @return modified vector
     # @example
@@ -461,7 +473,7 @@ module Daru
       @coding_scheme = scheme
     end
 
-    CODING_SCHEMES = [:dummy, :deviation, :helmert, :simple].freeze
+    CODING_SCHEMES = %i[dummy deviation helmert simple].freeze
 
     # Contrast code the vector acording to the coding scheme set.
     # @note To set the coding scheme use #coding_scheme=
@@ -584,7 +596,7 @@ module Daru
     alias :gteq :mteq
 
     # For querying the data
-    # @param [object] arel like query syntax
+    # @param bool_array [object] arel like query syntax
     # @return [Daru::Vector] Vector which makes the conditions true
     # @example
     #   dv = Daru::Vector.new ['I', 'II', 'I', 'III', 'I', 'II'],
@@ -658,7 +670,7 @@ module Daru
     end
 
     # Check if any one of mentioned values occur in the vector
-    # @param [Array] *values values to check for
+    # @param [Array] values to check for
     # @return [true, false] returns true if any one of specified values
     #   occur in the vector
     # @example
@@ -670,7 +682,7 @@ module Daru
     end
 
     # Return a vector with specified values removed
-    # @param [Array] *values values to reject from resultant vector
+    # @param [Array] values to reject from resultant vector
     # @return [Daru::Vector] vector with specified values removed
     # @example
     #   dv = Daru::Vector.new [1, 2, nil, Float::NAN], type: :category
@@ -689,7 +701,7 @@ module Daru
     end
 
     # Count the number of values specified
-    # @param [Array] *values values to count for
+    # @param [Array] values to count for
     # @return [Integer] the number of times the values mentioned occurs
     # @example
     #   dv = Daru::Vector.new [1, 2, 1, 2, 3, 4, nil, nil]
@@ -702,7 +714,7 @@ module Daru
     end
 
     # Return indexes of values specified
-    # @param [Array] *values values to find indexes for
+    # @param [Array] values to find indexes for
     # @return [Array] array of indexes of values specified
     # @example
     #   dv = Daru::Vector.new [1, 2, nil, Float::NAN], index: 11..14
@@ -743,6 +755,11 @@ module Daru
 
     private
 
+    # Will lazily load the plotting library being used
+    def init_plotting_library
+      self.plotting_library = Daru.plotting_library
+    end
+
     def validate_categories input_categories
       raise ArgumentError, 'Input categories and speculated categories mismatch' unless
         (categories - input_categories).empty?
@@ -763,9 +780,6 @@ module Daru
       # To link every instance to its category,
       # it stores integer for every instance representing its category
       @array = map_cat_int.values_at(*data)
-
-      # Include plotting functionality
-      self.plotting_library = Daru.plotting_library
     end
 
     def category_from_position position

data/lib/daru/configuration.rb

@@ -0,0 +1,34 @@
+module Daru
+  # Defines constants and methods related to configuration
+  module Configuration
+    INSPECT_OPTIONS_KEYS = [
+      :max_rows,
+      # Terminal
+      :spacing
+    ].freeze
+
+    # Jupyter
+    DEFAULT_MAX_ROWS = 30
+
+    # Terminal
+    DEFAULT_SPACING = 10
+
+    attr_accessor(*INSPECT_OPTIONS_KEYS)
+
+    def configure
+      yield self
+    end
+
+    def self.extended(base)
+      base.reset_options
+    end
+
+    def reset_options
+      self.max_rows  = DEFAULT_MAX_ROWS
+
+      self.spacing   = DEFAULT_SPACING
+    end
+  end
+
+  extend Configuration
+end

data/lib/daru/core/group_by.rb

@@ -1,30 +1,107 @@
 module Daru
   module Core
     class GroupBy
-      attr_reader :groups
+      class << self
+        extend Gem::Deprecate
+
+        # @private
+        def group_by_index_to_positions(indexes_with_positions, sort: false)
+          index_to_positions = {}
+
+          indexes_with_positions.each do |idx, position|
+            (index_to_positions[idx] ||= []) << position
+          end
+
+          if sort # TODO: maybe add a more "stable" sorting option?
+            sorted_keys = index_to_positions.keys.sort(&Daru::Core::GroupBy::TUPLE_SORTER)
+            index_to_positions = sorted_keys.map { |k| [k, index_to_positions[k]] }.to_h
+          end
+
+          index_to_positions
+        end
+        alias get_positions_group_map_on group_by_index_to_positions
+        deprecate :get_positions_group_map_on, :group_by_index_to_positions, 2019, 10
+
+        # @private
+        def get_positions_group_for_aggregation(multi_index, level=-1)
+          raise unless multi_index.is_a?(Daru::MultiIndex)
+
+          new_index = multi_index.dup
+          new_index.remove_layer(level) # TODO: recheck code of Daru::MultiIndex#remove_layer
+
+          group_by_index_to_positions(new_index.each_with_index)
+        end
+
+        # @private
+        def get_positions_group_map_for_df(df, group_by_keys, sort: true)
+          indexes_with_positions = df[*group_by_keys].to_df.each_row.map(&:to_a).each_with_index
+
+          group_by_index_to_positions(indexes_with_positions, sort: sort)
+        end
+
+        # @private
+        def group_map_from_positions_to_indexes(positions_group_map, index)
+          positions_group_map.map { |k, positions| [k, positions.map { |pos| index.at(pos) }] }.to_h
+        end
+
+        # @private
+        def df_from_group_map(df, group_map, remaining_vectors, from_position: true)
+          return nil if group_map == {}
+
+          new_index = group_map.flat_map { |group, values| values.map { |val| group + [val] } }
+          new_index = Daru::MultiIndex.from_tuples(new_index)
+
+          return Daru::DataFrame.new({}, index: new_index) if remaining_vectors == []
+
+          new_rows_order = group_map.values.flatten
+          new_df = df[*remaining_vectors].to_df.get_sub_dataframe(new_rows_order, by_position: from_position)
+          new_df.index = new_index
+
+          new_df
+        end
+      end
+
+      # The group_by was done over the vectors in group_vectors; the remaining vectors are the non_group_vectors
+      attr_reader :group_vectors, :non_group_vectors
+
+      # lazy accessor/attr_reader for the attribute groups
+      def groups
+        @groups ||= GroupBy.group_map_from_positions_to_indexes(@groups_by_pos, @context.index)
+      end
+      alias :groups_by_idx :groups
+
+      # lazy accessor/attr_reader for the attribute df
+      def df
+        @df ||= GroupBy.df_from_group_map(@context, @groups_by_pos, @non_group_vectors)
+      end
+      alias :grouped_df :df
 
       # Iterate over each group created by group_by. A DataFrame is yielded in
       # block.
       def each_group
+        return to_enum(:each_group) unless block_given?
+
         groups.keys.each do |k|
           yield get_group(k)
         end
       end
 
-      TUPLE_SORTER = lambda do |a, b|
-        if a && b
-          a.compact <=> b.compact
-        else
-          a ? 1 : -1
-        end
+      TUPLE_SORTER = lambda do |left, right|
+        return -1 unless right
+        return 1 unless left
+
+        left = left.compact
+        right = right.compact
+        return left <=> right || 0 if left.length == right.length
+        left.length <=> right.length
       end
 
       def initialize context, names
-        @groups = {}
+        @group_vectors     = names
         @non_group_vectors = context.vectors.to_a - names
-        @context = context
-        vectors = names.map { |vec| context[vec].to_a }
-        tuples  = vectors[0].zip(*vectors[1..-1])
+
+        @context = context # TODO: maybe rename in @original_df
+
         # FIXME: It feels like we don't want to sort here. Ruby's #group_by
         # never sorts:
         #
@@ -32,24 +109,14 @@ module Daru
         #   #  => {4=>["test"], 2=>["me"], 6=>["please"]}
         #
         # - zverok, 2016-09-12
-        keys    = tuples.uniq.sort(&TUPLE_SORTER)
-
-        keys.each do |key|
-          @groups[key] = all_indices_for(tuples, key)
-        end
-        @groups.freeze
+        @groups_by_pos = GroupBy.get_positions_group_map_for_df(@context, @group_vectors, sort: true)
       end
 
       # Get a Daru::Vector of the size of each group.
       def size
-        index =
-          if multi_indexed_grouping?
-            Daru::MultiIndex.from_tuples @groups.keys
-          else
-            Daru::Index.new @groups.keys.flatten
-          end
+        index = get_grouped_index
 
-        values = @groups.values.map(&:size)
+        values = @groups_by_pos.values.map(&:size)
         Daru::Vector.new(values, index: index, name: :size)
       end
 
@@ -196,27 +263,20 @@ module Daru
       #   #                    a          b          c          d
       #   #         5        bar        two          6         66
       def get_group group
-        indexes   = @groups[group]
+        indexes   = groups_by_idx[group]
         elements  = @context.each_vector.map(&:to_a)
         transpose = elements.transpose
         rows      = indexes.each.map { |idx| transpose[idx] }
 
-        new_index =
-          begin
-            @context.index[indexes]
-          rescue IndexError
-            indexes
-          end
-
         Daru::DataFrame.rows(
-          rows, index: new_index, order: @context.vectors
+          rows, index: indexes, order: @context.vectors
         )
       end
 
       # Iteratively applies a function to the values in a group and accumulates the result.
       # @param init (nil) The initial value of the accumulator.
-      # @param block [Proc] A proc or lambda that accepts two arguments.  The first argument
-      #                     is the accumulated result.  The second argument is a DataFrame row.
+      # @yieldparam block [Proc] A proc or lambda that accepts two arguments.  The first argument
+      #                          is the accumulated result.  The second argument is a DataFrame row.
       # @example Usage of reduce
       #   df = Daru::DataFrame.new({
       #     a: ['a','b'] * 3,
@@ -230,7 +290,7 @@ module Daru
       #   #   a ACE
       #   #   b BDF
       def reduce(init=nil)
-        result_hash = @groups.each_with_object({}) do |(group, indices), h|
+        result_hash = groups_by_idx.each_with_object({}) do |(group, indices), h|
           group_indices = indices.map { |v| @context.index.to_a[v] }
 
           grouped_result = init
@@ -241,23 +301,64 @@ module Daru
           h[group] = grouped_result
         end
 
-        index =
-          if multi_indexed_grouping?
-            Daru::MultiIndex.from_tuples result_hash.keys
-          else
-            Daru::Index.new result_hash.keys.flatten
-          end
+        index = get_grouped_index(result_hash.keys)
 
         Daru::Vector.new(result_hash.values, index: index)
       end
 
+      def inspect
+        grouped_df.inspect
+      end
+
+      # Function to use for aggregating the data.
+      # `group_by` is using Daru::DataFrame#aggregate
+      #
+      # @param options [Hash] options for column, you want in resultant dataframe
+      #
+      # @return [Daru::DataFrame]
+      #
+      # @example
+      #
+      #   df = Daru::DataFrame.new(
+      #     name: ['Ram','Krishna','Ram','Krishna','Krishna'],
+      #     visited: ['Hyderabad', 'Delhi', 'Mumbai', 'Raipur', 'Banglore'])
+      #
+      #   => #<Daru::DataFrame(5x2)>
+      #                   name   visited
+      #            0       Ram Hyderabad
+      #            1   Krishna     Delhi
+      #            2       Ram    Mumbai
+      #            3   Krishna    Raipur
+      #            4   Krishna  Banglore
+      #
+      #   df.group_by(:name)
+      #   => #<Daru::DataFrame(5x1)>
+      #                          visited
+      #      Krishna         1     Delhi
+      #                      3    Raipur
+      #                      4  Banglore
+      #          Ram         0 Hyderabad
+      #                      2    Mumbai
+      #
+      #   df.group_by(:name).aggregate(visited: -> (vec){vec.to_a.join(',')})
+      #   => #<Daru::DataFrame(2x1)>
+      #                  visited
+      #       Krishna Delhi,Raipur,Banglore
+      #           Ram Hyderabad,Mumbai
+      #
+      def aggregate(options={})
+        new_index = get_grouped_index
+
+        @context.aggregate(options) { [@groups_by_pos.values, new_index] }
+      end
+
       private
 
       def select_groups_from method, quantity
         selection     = @context
         rows, indexes = [], []
 
-        @groups.each_value do |index|
+        groups_by_idx.each_value do |index|
           index.send(method, quantity).each do |idx|
             rows << selection.row[idx].to_a
             indexes << idx
@@ -268,50 +369,30 @@ module Daru
         Daru::DataFrame.rows(rows, order: @context.vectors, index: indexes)
       end
 
-      def apply_method method_type, method
-        order = @non_group_vectors.select do |ngvec|
-          method_type == :numeric && @context[ngvec].type == :numeric
-        end
+      def select_numeric_non_group_vectors
+        @non_group_vectors.select { |ngvec| @context[ngvec].type == :numeric }
+      end
 
-        rows = @groups.map do |_group, indexes|
-          order.map do |ngvector|
-            slice = @context[ngvector][*indexes]
-            slice.is_a?(Daru::Vector) ? slice.send(method) : slice
-          end
-        end
+      def apply_method method_type, method
+        raise 'To implement' if method_type != :numeric
+        aggregation_options = select_numeric_non_group_vectors.map { |k| [k, method] }.to_h
 
-        index = apply_method_index
-        order = Daru::Index.new(order)
-        Daru::DataFrame.new(rows.transpose, index: index, order: order)
+        aggregate(aggregation_options)
       end
 
-      def apply_method_index
-        if multi_indexed_grouping?
-          Daru::MultiIndex.from_tuples(@groups.keys)
-        else
-          Daru::Index.new(@groups.keys.flatten)
-        end
-      end
+      def get_grouped_index(index_tuples=nil)
+        index_tuples = @groups_by_pos.keys if index_tuples.nil?
 
-      def all_indices_for arry, element
-        found, index, indexes = -1, -1, []
-        while found
-          found = arry[index+1..-1].index(element)
-          if found
-            index = index + found + 1
-            indexes << index
-          end
-        end
-        if indexes.count == 1
-          [@context.index.at(*indexes)]
+        if multi_indexed_grouping?
+          Daru::MultiIndex.from_tuples(index_tuples)
         else
-          @context.index.at(*indexes).to_a
+          Daru::Index.new(index_tuples.flatten)
         end
       end
 
       def multi_indexed_grouping?
-        return false unless @groups.keys[0]
-        @groups.keys[0].size > 1
+        return false unless @groups_by_pos.keys[0]
+        @groups_by_pos.keys[0].size > 1
       end
     end
   end