daru 0.1.6 → 0.2.0

data/lib/daru/date_time/index.rb

@@ -344,7 +344,7 @@ module Daru
 
     # Retreive a slice or a an individual index number from the index.
     #
-    # @param [String, DateTime] Specify a date partially (as a String) or
+    # @param key [String, DateTime] Specify a date partially (as a String) or
     #   completely to retrieve.
     def [] *key
       return slice(*key) if key.size != 1

data/lib/daru/date_time/offsets.rb

@@ -86,7 +86,7 @@ module Daru
 
   module Offsets
     class DateOffsetType < DateOffset
-      # @method initialize
+      # @!method initialize(n)
       # Initialize one of the subclasses of DateOffsetType with the number of the times
       # the offset should be applied, which is the supplied as the argument.
       #

data/lib/daru/extensions/which_dsl.rb

@@ -0,0 +1,55 @@
+# Support for a simple query DSL for accessing where(), inspired by gem "squeel"
+
+module Daru
+  class DataFrame
+    # a simple query DSL for accessing where(), inspired by gem "squeel"
+    # e.g.:
+    # df.which{ `FamilySize` == `FamilySize`.max }
+    # equals
+    # df.where( df['FamilySize'].eq( df['FamilySize'].max ) )
+    #
+    # e.g.:
+    # df.which{ (`NameTitle` == 'Dr') & (`Sex` == 'female') }
+    # equals
+    # df.where( df['NameTitle'].eq('Dr') & df['Sex'].eq('female') )
+    def which(&block)
+      WhichQuery.new(self, &block).exec
+    end
+  end
+
+  class WhichQuery
+    def initialize(df, &condition)
+      @df = df
+      @condition = condition
+    end
+
+    # executes a block of DSL code
+    def exec
+      query = instance_eval(&@condition)
+      @df.where(query)
+    end
+
+    def `(vector_name)
+      if !@df.has_vector?(vector_name) && @df.has_vector?(vector_name.to_sym)
+        vector_name = vector_name.to_sym
+      end
+      VectorWrapper.new(@df[vector_name])
+    end
+
+    class VectorWrapper < SimpleDelegator
+      {
+        :== => :eq,
+        :!= => :not_eq,
+        :<  => :lt,
+        :<= => :lteq,
+        :>  => :mt,
+        :>= => :mteq,
+        :=~ => :in
+      }.each do |opt, method|
+        define_method opt do |*args|
+          send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/daru/index/categorical_index.rb

@@ -45,7 +45,7 @@ module Daru
     # Returns positions given categories or positions
     # @note If the argument does not a valid category it treats it as position
     #   value and return it as it is.
-    # @param [Array<object>] *indexes categories or positions
+    # @param indexes [Array<object>] categories or positions
     # @example
     #   x = Daru::CategoricalIndex.new [:a, 1, :a, 1, :c]
     #   x.pos :a, 1
@@ -145,7 +145,7 @@ module Daru
     end
 
     # Return subset given categories or positions
-    # @param [Array<object>] *indexes categories or positions
+    # @param indexes [Array<object>] categories or positions
     # @return [Daru::CategoricalIndex] subset of the self containing the
     #   mentioned categories or positions
     # @example
@@ -161,7 +161,7 @@ module Daru
 
     # Takes positional values and returns subset of the self
     #   capturing the categories at mentioned positions
-    # @param [Array<Integer>] positional values
+    # @param positions [Array<Integer>] positional values
     # @return [object] index object
     # @example
     #   idx = Daru::CategoricalIndex.new [:a, :b, :a, :b, :c]
@@ -178,7 +178,7 @@ module Daru
     end
 
     # Add specified index values to the index object
-    # @param [Array<object>] *indexes index values to add
+    # @param indexes [Array<object>] index values to add
     # @return [Daru::CategoricalIndex] index object with added values
     # @example
     #   idx = Daru::CategoricalIndex.new [:a, :b, :a, :b, :c]

data/lib/daru/index/index.rb

@@ -90,7 +90,7 @@ module Daru
     end
 
     # Returns true if all arguments are either a valid category or position
-    # @param [Array<object>] *indexes categories or positions
+    # @param indexes [Array<object>] categories or positions
     # @return [true, false]
     # @example
     #   idx.valid? :a, 2
@@ -104,7 +104,7 @@ module Daru
     # Returns positions given indexes or positions
     # @note If the arugent is both a valid index and a valid position,
     #   it will treated as valid index
-    # @param [Array<object>] *indexes indexes or positions
+    # @param indexes [Array<object>] indexes or positions
     # @example
     #   x = Daru::Index.new [:a, :b, :c]
     #   x.pos :a, 1
@@ -136,7 +136,7 @@ module Daru
 
     # Takes positional values and returns subset of the self
     #   capturing the indexes at mentioned positions
-    # @param [Array<Integer>] positional values
+    # @param positions [Array<Integer>] positional values
     # @return [object] index object
     # @example
     #   idx = Daru::Index.new [:a, :b, :c]
@@ -218,7 +218,7 @@ module Daru
     # Return vector of booleans with value at ith position is either
     # true or false depending upon whether index value at position i is equal to
     # any of the values passed in the argument or not
-    # @param [Array] *indexes values to equate with
+    # @param indexes [Array] values to equate with
     # @return [Daru::Vector] vector of boolean values
     # @example
     #   dv = Daru::Index.new [1, 2, 3, :one, 'one']
@@ -258,7 +258,7 @@ module Daru
 
     # Provide an Index for sub vector produced
     #
-    # @param input_indexes [Array] the input by user to index the vector
+    # @option * [Array] the input by user to index the vector
     # @return [Object] the Index object for sub vector produced
     def conform(*)
       self

data/lib/daru/index/multi_index.rb

@@ -152,7 +152,7 @@ module Daru
     # Returns positions given indexes or positions
     # @note If the arugent is both a valid index and a valid position,
     #   it will treated as valid index
-    # @param [Array<object>] *indexes indexes or positions
+    # @param indexes [Array<object>] indexes or positions
     # @example
     #   idx = Daru::MultiIndex.from_tuples [[:a, :one], [:a, :two], [:b, :one], [:b, :two]]
     #   idx.pos :a
@@ -177,7 +177,7 @@ module Daru
 
     # Takes positional values and returns subset of the self
     #   capturing the indexes at mentioned positions
-    # @param [Array<Integer>] positional values
+    # @param positions [Array<Integer>] positional values
     # @return [object] index object
     # @example
     #   idx = Daru::MultiIndex.from_tuples [[:a, :one], [:a, :two], [:b, :one], [:b, :two]]
@@ -239,6 +239,15 @@ module Daru
       end
     end
 
+    def remove_layer layer_index
+      @levels.delete_at(layer_index)
+      @labels.delete_at(layer_index)
+      @name.delete_at(layer_index) unless @name.nil?
+
+      # CategoricalIndex is used , to allow duplicate indexes.
+      @levels.size == 1 ? Daru::CategoricalIndex.new(to_a.flatten) : self
+    end
+
     # Array `name` must have same length as levels and labels.
     def validate_name names, levels
       error_msg = "'names' and 'levels' should be of same size. Size of the "\

data/lib/daru/io/io.rb

@@ -110,7 +110,7 @@ module Daru
 
       # Execute a query and create a data frame from the result
       #
-      # @param dbh [DBI::DatabaseHandle, String] A DBI connection OR Path to a SQlite3 database.
+      # @param db [DBI::DatabaseHandle, String] A DBI connection OR Path to a SQlite3 database.
       # @param query [String] The query to be executed
       #
       # @return A dataframe containing the data resulting from the query

data/lib/daru/maths/arithmetic/vector.rb

@@ -42,6 +42,34 @@ module Daru
           recode { |e| e.round(precision) unless e.nil? }
         end
 
+        # Add specified vector.
+        #
+        # @param other [Daru::Vector] The vector thats added to this.
+        # @param opts [Boolean] :skipnil if true treats nils as 0.
+        #
+        # @example
+        #
+        #    v0 = Daru::Vector.new [1, 2, nil, nil]
+        #    v1 = Daru::Vector.new [2, 1, 3, nil]
+        #
+        #    irb> v0.add v1
+        #    =>  #<Daru::Vector(4)>
+        #          0   3
+        #          1   3
+        #          2 nil
+        #          3 nil
+        #
+        #    irb> v0.add v1, skipnil: true
+        #    =>  #<Daru::Vector(4)>
+        #          0   3
+        #          1   3
+        #          2   3
+        #          3   0
+        #
+        def add other, opts={}
+          v2v_binary :+, other, skipnil: opts.fetch(:skipnil, false)
+        end
+
         private
 
         def math_unary_op operation
@@ -62,19 +90,27 @@ module Daru
             name: @name, index: @index
         end
 
-        def v2v_binary operation, other
+        def v2v_binary operation, other, opts={}
           # FIXME: why the sorting?.. - zverok, 2016-05-18
           index = (@index.to_a | other.index.to_a).sort
 
           elements = index.map do |idx|
             this = self.index.include?(idx) ? self[idx] : nil
             that = other.index.include?(idx) ? other[idx] : nil
-
+            this, that = zero_nil_args(this, that, opts.fetch(:skipnil, false))
             this && that ? this.send(operation, that) : nil
           end
 
           Daru::Vector.new(elements, name: @name, index: index)
         end
+
+        def zero_nil_args(this, that, skipnil)
+          if skipnil
+            this = 0 if this.nil?
+            that = 0 if that.nil?
+          end
+          [this, that]
+        end
       end
     end
   end

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

@@ -41,35 +41,35 @@ module Daru
         #   Calculate cumulative sum of each numeric Vector
         # @!method standardize
         #   Standardize each Vector
-        # @!method acf
+        # @!method acf(max_lags)
         #   Calculate Autocorrelation coefficient
-        #   @param [Integer] max_lags (nil) Number of initial lags
-        # @!method ema
+        #   @param max_lags [Integer] (nil) Number of initial lags
+        # @!method ema(n,wilder)
         #   Calculate exponential moving average.
-        #   @param [Integer] n (10) Loopback length.
-        #   @param [TrueClass, FalseClass, NilClass] wilder (false) If true,
+        #   @param n [Integer] (10) Loopback length.
+        #   @param wilder [TrueClass, FalseClass, NilClass] (false) If true,
         #     1/n value is  used for smoothing; if false, uses 2/(n+1) value.
-        # @!method rolling_mean
+        # @!method rolling_mean(n)
         #   Calculate moving averages
-        #   @param [Integer] n (10) Loopback length. Default to 10.
-        # @!method rolling_median
+        #   @param n [Integer] (10) Loopback length. Default to 10.
+        # @!method rolling_median(n)
         #   Calculate moving median
-        #   @param [Integer] n (10) Loopback length. Default to 10.
-        # @!method rolling_max
+        #   @param n [Integer] (10) Loopback length. Default to 10.
+        # @!method rolling_max(n)
         #   Calculate moving max
-        #   @param [Integer] n (10) Loopback length. Default to 10.
-        # @!method rolling_min
+        #   @param n [Integer] (10) Loopback length. Default to 10.
+        # @!method rolling_min(n)
         #   Calculate moving min
-        #   @param [Integer] n (10) Loopback length. Default to 10.
-        # @!method rolling_count
+        #   @param n [Integer] (10) Loopback length. Default to 10.
+        # @!method rolling_count(n)
         #   Calculate moving non-missing count
-        #   @param [Integer] n (10) Loopback length. Default to 10.
-        # @!method rolling_std
+        #   @param n [Integer] (10) Loopback length. Default to 10.
+        # @!method rolling_std(n)
         #   Calculate moving standard deviation
-        #   @param [Integer] n (10) Loopback length. Default to 10.
-        # @!method rolling_variance
+        #   @param n [Integer] (10) Loopback length. Default to 10.
+        # @!method rolling_variance(n)
         #   Calculate moving variance
-        #   @param [Integer] n (10) Loopback length. Default to 10.
+        #   @param n [Integer] (10) Loopback length. Default to 10.
         %i[
           cumsum standardize acf ema rolling_mean rolling_median rolling_max
           rolling_min rolling_count rolling_std rolling_variance rolling_sum

data/lib/daru/maths/statistics/vector.rb

@@ -66,7 +66,185 @@ module Daru
           reject_values(*Daru::MISSING_VALUES).uniq.reset_index!
         end
 
-        # Returns the maximum value present in the vector.
+        if RUBY_VERSION >= '2.2'
+          # Returns the maximum value(s) present in the vector, with an optional comparator block.
+          #
+          # @param size [Integer] Number of maximum values to return. Defaults to nil.
+          #
+          # @example
+          #
+          #   dv = Daru::Vector.new (["Tyrion", "Daenerys", "Jon Starkgaryen"]), index: Daru::Index.new([:t, :d, :j])
+          #   #=>
+          #   #   #<Daru::Vector(3)>
+          #   #       t   Tyrion
+          #   #       d   Daenerys
+          #   #       j   Jon Starkgaryen
+          #
+          #   dv.max
+          #   #=> "Tyrion"
+          #
+          #   dv.max(2) { |a,b| a.size <=> b.size }
+          #   #=> ["Jon Starkgaryen","Daenerys"]
+          def max(size=nil, &block)
+            reject_values(*Daru::MISSING_VALUES).to_a.max(size, &block)
+          end
+
+          # Returns the maximum value(s) present in the vector, with a compulsory object block.
+          #
+          # @param size [Integer] Number of maximum values to return. Defaults to nil.
+          #
+          # @example
+          #
+          #   dv = Daru::Vector.new (["Tyrion", "Daenerys", "Jon Starkgaryen"]), index: Daru::Index.new([:t, :d, :j])
+          #   #=>
+          #   #   #<Daru::Vector(3)>
+          #   #       t   Tyrion
+          #   #       d   Daenerys
+          #   #       j   Jon Starkgaryen
+          #
+          #   dv.max_by(2) { |i| i.size }
+          #   #=> ["Jon Starkgaryen","Daenerys"]
+          def max_by(size=nil, &block)
+            raise ArgumentError, 'Expected compulsory object block in max_by method' unless block_given?
+            reject_values(*Daru::MISSING_VALUES).to_a.max_by(size, &block)
+          end
+
+          # Returns the minimum value(s) present in the vector, with an optional comparator block.
+          #
+          # @param size [Integer] Number of minimum values to return. Defaults to nil.
+          #
+          # @example
+          #
+          #   dv = Daru::Vector.new (["Tyrion", "Daenerys", "Jon Starkgaryen"]), index: Daru::Index.new([:t, :d, :j])
+          #   #=>
+          #   #   #<Daru::Vector(3)>
+          #   #       t   Tyrion
+          #   #       d   Daenerys
+          #   #       j   Jon Starkgaryen
+          #
+          #   dv.min
+          #   #=> "Daenerys"
+          #
+          #   dv.min(2) { |a,b| a.size <=> b.size }
+          #   #=> ["Tyrion","Daenerys"]
+          def min(size=nil, &block)
+            reject_values(*Daru::MISSING_VALUES).to_a.min(size, &block)
+          end
+
+          # Returns the minimum value(s) present in the vector, with a compulsory object block.
+          #
+          # @param size [Integer] Number of minimum values to return. Defaults to nil.
+          #
+          # @example
+          #
+          #   dv = Daru::Vector.new (["Tyrion", "Daenerys", "Jon Starkgaryen"]), index: Daru::Index.new([:t, :d, :j])
+          #   #=>
+          #   #   #<Daru::Vector(3)>
+          #   #       t   Tyrion
+          #   #       d   Daenerys
+          #   #       j   Jon Starkgaryen
+          #
+          #   dv.min_by(2) { |i| i.size }
+          #   #=> ["Tyrion","Daenerys"]
+          def min_by(size=nil, &block)
+            raise ArgumentError, 'Expected compulsory object block in min_by method' unless block_given?
+            reject_values(*Daru::MISSING_VALUES).to_a.min_by(size, &block)
+          end
+        else
+          # Returns the maximum value(s) present in the vector, with an optional comparator block.
+          #
+          # @param size [Integer] Number of maximum values to return. Defaults to nil.
+          #
+          # @example
+          #
+          #   dv = Daru::Vector.new (["Tyrion", "Daenerys", "Jon Starkgaryen"]), index: Daru::Index.new([:t, :d, :j])
+          #   #=>
+          #   #   #<Daru::Vector(3)>
+          #   #       t   Tyrion
+          #   #       d   Daenerys
+          #   #       j   Jon Starkgaryen
+          #
+          #   dv.max
+          #   #=> "Tyrion"
+          #
+          #   dv.max(2) { |a,b| a.size <=> b.size }
+          #   #=> ["Jon Starkgaryen","Daenerys"]
+          def max(size=nil, &block)
+            range = size.nil? ? 0 : (0..size-1)
+            reject_values(*Daru::MISSING_VALUES).to_a.sort(&block).reverse[range]
+          end
+
+          # Returns the maximum value(s) present in the vector, with a compulsory object block.
+          #
+          # @param size [Integer] Number of maximum values to return. Defaults to nil.
+          #
+          # @example
+          #
+          #   dv = Daru::Vector.new (["Tyrion", "Daenerys", "Jon Starkgaryen"]), index: Daru::Index.new([:t, :d, :j])
+          #   #=>
+          #   #   #<Daru::Vector(3)>
+          #   #       t   Tyrion
+          #   #       d   Daenerys
+          #   #       j   Jon Starkgaryen
+          #
+          #   dv.max_by(2) { |i| i.size }
+          #   #=> ["Jon Starkgaryen","Daenerys"]
+          def max_by(size=nil, &block)
+            raise ArgumentError, 'Expected compulsory object block in max_by method' unless block_given?
+            reject_values(*Daru::MISSING_VALUES).to_a.sort_by(&block).reverse[size.nil? ? 0 : (0..size-1)]
+          end
+
+          # Returns the minimum value(s) present in the vector, with an optional comparator block.
+          #
+          # @param size [Integer] Number of minimum values to return. Defaults to nil.
+          #
+          # @example
+          #
+          #   dv = Daru::Vector.new (["Tyrion", "Daenerys", "Jon Starkgaryen"]), index: Daru::Index.new([:t, :d, :j])
+          #   #=>
+          #   #   #<Daru::Vector(3)>
+          #   #       t   Tyrion
+          #   #       d   Daenerys
+          #   #       j   Jon Starkgaryen
+          #
+          #   dv.min
+          #   #=> "Daenerys"
+          #
+          #   dv.min(2) { |a,b| a.size <=> b.size }
+          #   #=> ["Tyrion","Daenerys"]
+          def min(size=nil, &block)
+            range = size.nil? ? 0 : (0..size-1)
+            reject_values(*Daru::MISSING_VALUES).to_a.sort(&block)[range]
+          end
+
+          # Returns the minimum value(s) present in the vector, with a compulsory object block.
+          #
+          # @param size [Integer] Number of minimum values to return. Defaults to nil.
+          #
+          # @example
+          #
+          #   dv = Daru::Vector.new (["Tyrion", "Daenerys", "Jon Starkgaryen"]), index: Daru::Index.new([:t, :d, :j])
+          #   #=>
+          #   #   #<Daru::Vector(3)>
+          #   #       t   Tyrion
+          #   #       d   Daenerys
+          #   #       j   Jon Starkgaryen
+          #
+          #   dv.min_by
+          #   #=> "Daenerys"
+          #
+          #   dv.min_by(2) { |i| i.size }
+          #   #=> ["Tyrion","Daenerys"]
+          def min_by(size=nil, &block)
+            raise ArgumentError, 'Expected compulsory object block in min_by method' unless block_given?
+            reject_values(*Daru::MISSING_VALUES).to_a.sort_by(&block)[size.nil? ? 0 : (0..size-1)]
+          end
+        end
+
+        # Returns the index of the maximum value(s) present in the vector, with an optional
+        # comparator block.
+        #
+        # @param size [Integer] Number of maximum indices to return. Defaults to nil.
         #
         # @example
         #
@@ -77,29 +255,21 @@ module Daru
         #   #       d   Daenerys
         #   #       j   Jon Starkgaryen
         #
-        #   dv.max
-        #   #=> "Tyrion"
-        #
-        #   dv.max(2) { |a,b| a.size <=> b.size }
-        #   #=> ["Jon Starkgaryen","Daenerys"]
+        #   dv.index_of_max
+        #   #=> :t
         #
-        #   dv.max(2) { |i| i.size }
-        #   #=> ["Jon Starkgaryen","Daenerys"]
-        def max(size=nil, &block)
-          data = @data.data.to_a
-          data = if block_given?
-                   if block.parameters.count == 1 # Object block like { |x| x.size }
-                     data.sort_by(&block)
-                   else # Comparative block like { |a,b| a.size <=> b.size }
-                     data.sort(&block)
-                   end
-                 else
-                   data.sort
-                 end
-          size.nil? ? data.last : data[data.count-size..-1].reverse
+        #   dv.index_of_max(2) { |a,b| a.size <=> b.size }
+        #   #=> [:j, :d]
+        def index_of_max(size=nil,&block)
+          vals = max(size, &block)
+          dv   = reject_values(*Daru::MISSING_VALUES)
+          vals.is_a?(Array) ? (vals.map { |x| dv.index_of(x) }) : dv.index_of(vals)
         end
 
-        # Returns the index of the maximum value present in the vector.
+        # Returns the index of the maximum value(s) present in the vector, with a compulsory
+        # object block.
+        #
+        # @param size [Integer] Number of maximum indices to return. Defaults to nil.
         #
         # @example
         #
@@ -110,22 +280,18 @@ module Daru
         #   #       d   Daenerys
         #   #       j   Jon Starkgaryen
         #
-        #   dv.index_of_max
-        #   #=> :t
-        #
-        #   dv.index_of_max(2) { |a,b| a.size <=> b.size }
-        #   #=> [:j, :d]
-        #
-        #   dv.max(2) { |i| i.size }
+        #   dv.index_of_max_by(2) { |i| i.size }
         #   #=> [:j, :d]
-        def index_of_max(size=nil,&block)
-          data = @data.data.to_a
-          indx = @index.to_a
-          vals = max(size,&block)
-          vals.is_a?(Array) ? (vals.map { |x| indx[data.index(x)] }) : indx[data.index(vals)]
+        def index_of_max_by(size=nil,&block)
+          vals = max_by(size, &block)
+          dv   = reject_values(*Daru::MISSING_VALUES)
+          vals.is_a?(Array) ? (vals.map { |x| dv.index_of(x) }) : dv.index_of(vals)
         end
 
-        # Returns the minimum value present in the vector.
+        # Returns the index of the minimum value(s) present in the vector, with an optional
+        # comparator block.
+        #
+        # @param size [Integer] Number of minimum indices to return. Defaults to nil.
         #
         # @example
         #
@@ -136,29 +302,21 @@ module Daru
         #   #       d   Daenerys
         #   #       j   Jon Starkgaryen
         #
-        #   dv.min
-        #   #=> "Daenerys"
-        #
-        #   dv.min(2) { |a,b| a.size <=> b.size }
-        #   #=> ["Tyrion","Daenerys"]
+        #   dv.index_of_min
+        #   #=> :d
         #
-        #   dv.min(2) { |i| i.size }
-        #   #=> ["Tyrion","Daenerys"]
-        def min(size=nil, &block)
-          data = @data.data.to_a
-          data = if block_given?
-                   if block.parameters.count == 1 # Object block like { |x| x.size }
-                     data.sort_by(&block)
-                   else # Comparative block like { |a,b| a.size <=> b.size }
-                     data.sort(&block)
-                   end
-                 else
-                   data.sort
-                 end
-          size.nil? ? data.first : data[0..size-1]
+        #   dv.index_of_min(2) { |a,b| a.size <=> b.size }
+        #   #=> [:t, :d]
+        def index_of_min(size=nil,&block)
+          vals = min(size, &block)
+          dv   = reject_values(*Daru::MISSING_VALUES)
+          vals.is_a?(Array) ? (vals.map { |x| dv.index_of(x) }) : dv.index_of(vals)
         end
 
-        # Returns the index of the minimum value present in the vector.
+        # Returns the index of the minimum value(s) present in the vector, with a compulsory
+        # object block.
+        #
+        # @param size [Integer] Number of minimum indices to return. Defaults to nil.
         #
         # @example
         #
@@ -169,19 +327,12 @@ module Daru
         #   #       d   Daenerys
         #   #       j   Jon Starkgaryen
         #
-        #   dv.index_of_min
-        #   #=> :d
-        #
-        #   dv.index_of_min(2) { |a,b| a.size <=> b.size }
-        #   #=> [:t, :d]
-        #
         #   dv.index_of_min(2) { |i| i.size }
         #   #=> [:t, :d]
-        def index_of_min(size=nil,&block)
-          data = @data.data.to_a
-          indx = @index.to_a
-          vals = min(size,&block)
-          vals.is_a?(Array) ? (vals.map { |x| indx[data.index(x)] }) : indx[data.index(vals)]
+        def index_of_min_by(size=nil,&block)
+          vals = min_by(size, &block)
+          dv   = reject_values(*Daru::MISSING_VALUES)
+          vals.is_a?(Array) ? (vals.map { |x| dv.index_of(x) }) : dv.index_of(vals)
         end
 
         # Return the maximum element present in the Vector, as a Vector.
@@ -205,7 +356,7 @@ module Daru
         def proportions
           len = size - count_values(*Daru::MISSING_VALUES)
           frequencies.to_h.each_with_object({}) do |(el, count), hash|
-            hash[el] = count / len
+            hash[el] = count / len.to_f
           end
         end
 
@@ -549,28 +700,28 @@ module Daru
 
         # @!method rolling_mean
         #   Calculate rolling average
-        #   @param [Integer] n (10) Loopback length
+        #   @yieldparam [Integer] n (10) Loopback length
         # @!method rolling_median
         #   Calculate rolling median
-        #   @param [Integer] n (10) Loopback length
+        #   @yieldparam [Integer] n (10) Loopback length
         # @!method rolling_count
         #   Calculate rolling non-missing count
-        #   @param [Integer] n (10) Loopback length
+        #   @yieldparam [Integer] n (10) Loopback length
         # @!method rolling_max
         #   Calculate rolling max value
-        #   @param [Integer] n (10) Loopback length
+        #   @yieldparam [Integer] n (10) Loopback length
         # @!method rolling_min
         #   Calculate rolling min value
-        #   @param [Integer] n (10) Loopback length
+        #   @yieldparam [Integer] n (10) Loopback length
         # @!method rolling_sum
         #   Calculate rolling sum
-        #   @param [Integer] n (10) Loopback length
+        #   @yieldparam [Integer] n (10) Loopback length
         # @!method rolling_std
         #   Calculate rolling standard deviation
-        #   @param [Integer] n (10) Loopback length
+        #   @yieldparam [Integer] n (10) Loopback length
         # @!method rolling_variance
         #   Calculate rolling variance
-        #   @param [Integer] n (10) Loopback length
+        #   @yieldparam [Integer] n (10) Loopback length
         %i[count mean median max min sum std variance].each do |meth|
           define_method("rolling_#{meth}".to_sym) do |n=10|
             rolling(meth, n)
@@ -791,10 +942,6 @@ module Daru
         alias :ss :sum_of_squares
         alias :percentil :percentile
         alias :se :standard_error
-        alias :max_by :max
-        alias :min_by :min
-        alias :index_of_max_by :index_of_max
-        alias :index_of_min_by :index_of_min
 
         private