daru 0.1.2 → 0.1.3

data/lib/daru/monkeys.rb

@@ -6,35 +6,23 @@ class Array
   #   a.recode_repeated
   #   => ["a","b","c_1","c_2","d_1","d_2","d_3","e"]
   def recode_repeated
-    if size != uniq.size
-      # Find repeated
-      repeated = inject({}) do |acc, v|
-        if acc[v].nil?
-          acc[v] = 1
-        else
-          acc[v] += 1
-        end
-        acc
-      end.select { |_k, v| v > 1 }.keys
-
-      ns = repeated.inject({}) do |acc, v|
-        acc[v] = 0
-        acc
-      end
+    return self if size == uniq.size
+
+    duplicated = group_by { |n| n }
+                 .select { |_, g| g.size > 1 }.map(&:first)
 
-      collect do |f|
-        if repeated.include? f
-          ns[f] += 1
-          sprintf('%s_%d', f, ns[f])
-        else
-          f
-        end
+    counter = duplicated.collect { |n| [n, 0] }.to_h
+
+    collect do |n|
+      if counter.key?(n)
+        counter[n] += 1
+        '%s_%d' % [n, counter[n]]
+      else
+        n
       end
-    else
-      self
     end
   end
-  
+
   def daru_vector name=nil, index=nil, dtype=:array
     Daru::Vector.new self, name: name, index: index, dtype: dtype
   end
@@ -54,20 +42,20 @@ class Range
   alias_method :dv, :daru_vector
 
   def to_index
-    Daru::Index.new self.to_a
+    Daru::Index.new to_a
   end
 end
 
 class Hash
   def daru_vector index=nil, dtype=:array
-    Daru::Vector.new self.values[0], name: self.keys[0], index: index, dtype: dtype
+    Daru::Vector.new values[0], name: keys[0], index: index, dtype: dtype
   end
 
   alias_method :dv, :daru_vector
 end
 
 class NMatrix
-  def daru_vector name=nil, index=nil, dtype=NMatrix
+  def daru_vector(name=nil, index=nil, *)
     Daru::Vector.new self, name: name, index: index, dtype: :nmatrix
   end
 
@@ -75,7 +63,7 @@ class NMatrix
 end
 
 class MDArray
-  def daru_vector name=nil, index=nil, dtype=MDArray
+  def daru_vector(name=nil, index=nil, *)
     Daru::Vector.new self, name: name, index: index, dtype: :mdarray
   end
 
@@ -90,7 +78,7 @@ end
 
 class Matrix
   def elementwise_division other
-    self.map.with_index do |e, index|
+    map.with_index do |e, index|
       e / other.to_a.flatten[index]
     end
   end
@@ -104,4 +92,9 @@ class String
       false
     end
   end
+end
+
+class Daru::DataFrame
+  # NOTE: This alias will soon be removed. Use to_h in all future work.
+  alias :to_hash :to_h
 end

data/lib/daru/plotting/dataframe.rb

@@ -1,20 +1,20 @@
 module Daru
   module Plotting
     module DataFrame
-      # Plots a DataFrame with Nyaplot on IRuby using the given options. Yields 
+      # Plots a DataFrame with Nyaplot on IRuby using the given options. Yields
       # the corresponding Nyaplot::Plot object and the Nyaplot::Diagram object
       # to the block, if it is specified. See the nyaplot docs for info on how to
       # further use these objects.
-      # 
-      # Detailed instructions on use of the plotting API can be found in the 
+      #
+      # Detailed instructions on use of the plotting API can be found in the
       # notebooks whose links you can find in the README.
-      # 
+      #
       # == Options
-      # 
+      #
       # * +:type+  - Type of plot. Can be :scatter, :bar, :histogram, :line or :box.
       # * +:x+ - Vector to be used for X co-ordinates.
       # * +:y+ - Vector to be used for Y co-ordinates.
-      # 
+      #
       # == Usage
       #   # Simple bar chart
       #   df = Daru::DataFrame.new({a:['A', 'B', 'C', 'D', 'E'], b:[10,20,30,40,50]})
@@ -28,27 +28,28 @@ module Daru
         types = extract_option :type, options
 
         diagram =
-        case 
-        when !([:scatter, :bar, :line, :histogram] & types).empty?
-          if single_diagram? options
-            add_single_diagram plot, options
-          else
-            add_multiple_diagrams plot, options
+          case
+          when !([:scatter, :bar, :line, :histogram] & types).empty?
+            if single_diagram? options
+              add_single_diagram plot, options
+            else
+              add_multiple_diagrams plot, options
+            end
+          when types.include?(:box)
+            numeric = only_numerics(clone: false).dup_only_valid
+
+            plot.add_with_df(
+              numeric.to_nyaplotdf,
+              :box, *numeric.vectors.to_a
+            )
           end
-        when types.include?(:box)
-          numeric = self.only_numerics(clone: false).dup_only_valid
-
-          plot.add_with_df(
-            numeric.to_nyaplotdf,
-            :box, *numeric.vectors.to_a)
-        end
 
         yield(plot, diagram) if block_given?
 
         plot.show
       end
 
-     private
+      private
 
       def single_diagram? options
         options[:x] and options[:x].is_a?(Symbol)
@@ -56,12 +57,12 @@ module Daru
 
       def add_single_diagram plot, options
         args = [
-          self.to_nyaplotdf, 
-          options[:type], 
+          to_nyaplotdf,
+          options[:type],
           options[:x]
         ]
 
-        args << options[:y] if(options[:y])
+        args << options[:y] if options[:y]
 
         plot.add_with_df(*args)
       end
@@ -72,11 +73,10 @@ module Daru
         y_vecs = extract_option :y, options
 
         diagrams   = []
-        nyaplot_df = self.to_nyaplotdf
+        nyaplot_df = to_nyaplotdf
         total      = x_vecs.size
         types = types.size < total ? types*total : types
 
-
         (0...total).each do |i|
           diagrams << plot.add_with_df(
             nyaplot_df,
@@ -95,11 +95,10 @@ module Daru
           o.is_a?(Array) ? o : [o]
         else
           arr = options.keys
-          arr.keep_if { |a| a =~ Regexp.new("\\A#{opt.to_s}") }.sort
+          arr.keep_if { |a| a =~ Regexp.new("\\A#{opt}") }.sort
           arr.map { |a| options[a] }
         end
       end
-
     end
   end
-end if Daru.has_nyaplot?
+end if Daru.has_nyaplot?

data/lib/daru/plotting/vector.rb

@@ -1,22 +1,21 @@
 module Daru
   module Plotting
     module Vector
-
       # Plots a Vector with Nyaplot on IRuby using the given options. Yields the
-      # plot object (Nyaplot::Plot) and the diagram object (Nyaplot::Diagram) 
-      # to the block, which can be used for setting various options as per the 
+      # plot object (Nyaplot::Plot) and the diagram object (Nyaplot::Diagram)
+      # to the block, which can be used for setting various options as per the
       # Nyaplot API.
-      # 
+      #
       # == Options
       #   type (:scatter, :bar, :histogram), title, x_label, y_label, color(true/false)
-      # 
+      #
       # == Usage
       #   vector = Daru::Vector.new [10,20,30,40], [:one, :two, :three, :four]
       #   vector.plot(type: :bar) do |plot|
       #     plot.title "My first plot"
       #     plot.width 1200
       #   end
-      def plot opts={}, &block
+      def plot opts={}
         options = {
           type: :scatter
         }.merge(opts)
@@ -24,16 +23,16 @@ module Daru
         x_axis  = options[:type] == :scatter ? Array.new(@size) { |i| i } : @index.to_a
         plot    = Nyaplot::Plot.new
         diagram =
-        if [:box, :histogram].include? options[:type]
-          plot.add(options[:type], @data.to_a)
-        else
-          plot.add(options[:type], x_axis, @data.to_a)
-        end
+          if [:box, :histogram].include? options[:type]
+            plot.add(options[:type], @data.to_a)
+          else
+            plot.add(options[:type], x_axis, @data.to_a)
+          end
 
         yield plot, diagram if block_given?
-        
+
         plot.show
       end
     end
   end
-end if Daru.has_nyaplot?
+end if Daru.has_nyaplot?

data/lib/daru/vector.rb

@@ -1,11 +1,9 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'maths/arithmetic/vector.rb'
-require 'maths/statistics/vector.rb'
-require 'plotting/vector.rb'
-require 'accessors/array_wrapper.rb'
-require 'accessors/nmatrix_wrapper.rb'
-require 'accessors/gsl_wrapper.rb'
+require 'daru/maths/arithmetic/vector.rb'
+require 'daru/maths/statistics/vector.rb'
+require 'daru/plotting/vector.rb'
+require 'daru/accessors/array_wrapper.rb'
+require 'daru/accessors/nmatrix_wrapper.rb'
+require 'daru/accessors/gsl_wrapper.rb'
 
 module Daru
   class Vector
@@ -28,10 +26,10 @@ module Daru
       self
     end
 
-    def each_with_index(&block)
+    def each_with_index
       return to_enum(:each_with_index) unless block_given?
 
-      @index.each { |i|  yield(self[i], i) }
+      @index.each { |i| yield(self[i], i) }
       self
     end
 
@@ -59,6 +57,10 @@ module Daru
     # Store a hash of labels for values. Supplementary only. Recommend using index
     # for proper usage.
     attr_accessor :labels
+    # Store vector data in an array
+    attr_reader :data
+    # Attach arbitrary metadata to vector (usu a hash)
+    attr_accessor :metadata
 
     # Create a Vector object.
     #
@@ -97,11 +99,13 @@ module Daru
         source = source.values
       else
         index  = opts[:index]
-        source = source || []
+        source ||= []
       end
-      name   = opts[:name]
+      name = opts[:name]
       set_name name
 
+      @metadata = opts[:metadata] || {}
+
       @data  = cast_vector_to(opts[:dtype] || :array, source, opts[:nm_dtype])
       @index = try_create_index(index || @data.size)
 
@@ -137,11 +141,10 @@ module Daru
       value = opts[:value]
       opts.delete :value
       if block
-        vector = Daru::Vector.new n.times.map { |i| block.call(i) }, opts
+        Daru::Vector.new Array.new(n) { |i| block.call(i) }, opts
       else
-        vector = Daru::Vector.new n.times.map { value }, opts
+        Daru::Vector.new Array.new(n) { value }, opts
       end
-      vector
     end
 
     # Create a vector using (almost) any object
@@ -180,7 +183,7 @@ module Daru
         when Daru::Vector
           values.concat a.to_a
         when Range
-          values.concat  a.to_a
+          values.concat a.to_a
         else
           values << a
         end
@@ -199,56 +202,18 @@ module Daru
     #
     #   # 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
+    def [](*input_indexes)
+      # Get a proper index object
+      indexes = @index[*input_indexes]
 
-          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
+      # If one object is asked return it
+      return @data[indexes] if indexes.is_a? Numeric
 
-        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
-
-        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
-      end
+      # Form a new Vector using indexes and return it
+      Daru::Vector.new(
+        indexes.map { |loc| @data[@index[loc]] },
+        name: @name, metadata: @metadata.dup, index: indexes.conform(input_indexes), dtype: @dtype
+      )
     end
 
     # Just like in Hashes, you can specify the index label of the Daru::Vector
@@ -265,15 +230,14 @@ module Daru
     #   #  b   2
     #   #  c   3
     def []=(*location, value)
-      cast(dtype: :array) if value.nil? and dtype != :array
+      cast(dtype: :array) if value.nil? && dtype != :array
 
-      @possibly_changed_type = true if @type == :object  and (value.nil? or
+      @possibly_changed_type = true if @type == :object  && (value.nil? ||
         value.is_a?(Numeric))
-      @possibly_changed_type = true if @type == :numeric and (!value.is_a?(Numeric) and
+      @possibly_changed_type = true if @type == :numeric && (!value.is_a?(Numeric) &&
         !value.nil?)
 
-      location = location[0] unless @index.is_a?(MultiIndex)
-      pos      = @index[location]
+      pos = @index[*location]
 
       if pos.is_a?(Numeric)
         @data[pos] = value
@@ -315,9 +279,7 @@ module Daru
     # assignment/deletion of elements is done. Updating data this way is called
     # lazy loading. To set or unset lazy loading, see the .lazy_update= method.
     def update
-      if Daru.lazy_update
-        set_missing_positions
-      end
+      Daru.lazy_update and set_missing_positions
     end
 
     # Two vectors are equal if the have the exact same index values corresponding
@@ -325,10 +287,8 @@ module Daru
     def == other
       case other
       when Daru::Vector
-        @index == other.index and @size == other.size and
-        @index.all? do |index|
-          self[index] == other[index]
-        end
+        @index == other.index && @size == other.size &&
+          @index.all? { |index| self[index] == other[index] }
       else
         super
       end
@@ -369,12 +329,12 @@ module Daru
     # written above for functionality of each method. Use these methods with the
     # `where` method to obtain the corresponding Vector/DataFrame.
     {
-      :eq     => :==,
-      :not_eq => :!=,
-      :lt     => :<,
-      :lteq   => :<=,
-      :mt     => :>,
-      :mteq   => :>=,
+      eq: :==,
+      not_eq: :!=,
+      lt: :<,
+      lteq: :<=,
+      mt: :>,
+      mteq: :>=
     }.each do |method, operator|
       define_method(method) do |other|
         mod = Daru::Core::Query
@@ -403,9 +363,8 @@ module Daru
     def in other
       other = Hash[other.zip(Array.new(other.size, 0))]
       Daru::Core::Query::BoolArray.new(
-        @data.inject([]) do |memo, d|
-          memo << (other.has_key?(d) ? true : false)
-          memo
+        @data.each_with_object([]) do |d, memo|
+          memo << (other.key?(d) ? true : false)
         end
       )
     end
@@ -447,7 +406,7 @@ module Daru
     #   # 13   5
     #   # 15   1
     def where bool_arry
-      Daru::Core::Query.vector_where @data.to_a, @index.to_a, bool_arry, self.dtype
+      Daru::Core::Query.vector_where @data.to_a, @index.to_a, bool_arry, dtype
     end
 
     def head q=10
@@ -458,18 +417,21 @@ module Daru
       self[(@size - q)..(@size-1)]
     end
 
+    def empty?
+      @index.empty?
+    end
+
     # Reports whether missing data is present in the Vector.
     def has_missing_data?
       !missing_positions.empty?
     end
     alias :flawed? :has_missing_data?
 
-
     # Append an element to the vector by specifying the element and index
     def concat element, index
-      raise IndexError, "Expected new unique index" if @index.include? index
+      raise IndexError, 'Expected new unique index' if @index.include? index
 
-      @index = @index | [index]
+      @index |= [index]
       @data[@index[index]] = element
 
       set_size
@@ -486,14 +448,14 @@ module Daru
     def cast opts={}
       dt = opts[:dtype]
       raise ArgumentError, "Unsupported dtype #{opts[:dtype]}" unless
-        dt == :array or dt == :nmatrix or dt == :gsl
+        dt == :array || dt == :nmatrix || dt == :gsl
 
       @data = cast_vector_to dt unless @dtype == dt
     end
 
     # Delete an element by value
     def delete element
-      self.delete_at index_of(element)
+      delete_at index_of(element)
     end
 
     # Delete element by index
@@ -514,15 +476,12 @@ module Daru
     def type
       return @data.nm_dtype if dtype == :nmatrix
 
-      if @type.nil? or @possibly_changed_type
+      if @type.nil? || @possibly_changed_type
         @type = :numeric
-        self.each do |e|
-          unless e.nil?
-            unless e.is_a?(Numeric)
-              @type = :object
-              break
-            end
-          end
+        each do |e|
+          next if e.nil? || e.is_a?(Numeric)
+          @type = :object
+          break
         end
         @possibly_changed_type = false
       end
@@ -532,18 +491,20 @@ module Daru
 
     # Get index of element
     def index_of element
-      @index.key @data.index(element)
+      case dtype
+      when :array then @index.key @data.index { |x| x.eql? element }
+      else @index.key @data.index(element)
+      end
     end
 
     # Keep only unique elements of the vector alongwith their indexes.
     def uniq
       uniq_vector = @data.uniq
-      new_index   = uniq_vector.inject([]) do |acc, element|
+      new_index   = uniq_vector.each_with_object([]) do |element, acc|
         acc << index_of(element)
-        acc
       end
 
-      Daru::Vector.new uniq_vector, name: @name, index: new_index, dtype: @dtype
+      Daru::Vector.new uniq_vector, name: @name, metadata: @metadata.dup, index: new_index, dtype: @dtype
     end
 
     def any? &block
@@ -570,29 +531,34 @@ module Daru
     #   v = Daru::Vector.new ["My first guitar", "jazz", "guitar"]
     #   # Say you want to sort these strings by length.
     #   v.sort(ascending: false) { |a,b| a.length <=> b.length }
-    def sort opts={}, &block
+    def sort opts={}
       opts = {
-        ascending: true,
-        type: :quick_sort
+        ascending: true
       }.merge(opts)
 
-      block = lambda { |a,b|
-        return a <=> b if !(a.nil? || b.nil?)
-
-        if a.nil? && b.nil?
-          0
-        elsif a.nil?
-          -1
+      vector_index = @data.each_with_index
+      vector_index =
+        if block_given?
+          vector_index.sort { |a,b| yield(a[0], b[0]) }
         else
-          1
+          vector_index.sort { |(av, ai), (bv, bi)|
+            if !av.nil? && !bv.nil?
+              av <=> bv
+            elsif av.nil? && bv.nil?
+              ai <=> bi
+            elsif av.nil?
+              opts[:ascending] ? -1 : 1
+            else
+              opts[:ascending] ? 1 : -1
+            end
+          }
         end
-      } unless block
-
-      order = opts[:ascending] ? :ascending : :descending
-      vector, index = send(opts[:type], @data.to_a.dup, @index.to_a, order, &block)
-      index = Daru::Index.new index
+      vector_index.reverse! unless opts[:ascending]
+      vector, index = vector_index.transpose
+      old_index = @index.to_a
+      index = index.map { |i| old_index[i] }
 
-      Daru::Vector.new(vector, index: index, name: @name, dtype: @dtype)
+      Daru::Vector.new(vector, index: index, name: @name, metadata: @metadata.dup, dtype: @dtype)
     end
 
     # Just sort the data and get an Array in return using Enumerable#sort.
@@ -604,7 +570,7 @@ module Daru
     # Returns *true* if the value passed is actually exists or is not marked as
     # a *missing value*.
     def exists? value
-      !@missing_values.has_key?(self[index_of(value)])
+      !@missing_values.key?(self[index_of(value)])
     end
 
     # Like map, but returns a Daru::Vector with the returned values.
@@ -624,7 +590,7 @@ module Daru
     end
 
     # Delete an element if block returns true. Destructive.
-    def delete_if &block
+    def delete_if
       return to_enum(:delete_if) unless block_given?
 
       keep_e = []
@@ -645,7 +611,7 @@ module Daru
     end
 
     # Keep an element if block returns true. Destructive.
-    def keep_if &block
+    def keep_if
       return to_enum(:keep_if) unless block_given?
 
       keep_e = []
@@ -667,12 +633,10 @@ module Daru
 
     # Reports all values that doesn't comply with a condition.
     # Returns a hash with the index of data and the invalid data.
-    def verify &block
+    def verify
       h = {}
       (0...size).each do |i|
-        if !(yield @data[i])
-          h[i] = @data[i]
-        end
+        h[i] = @data[i] unless yield(@data[i])
       end
 
       h
@@ -683,7 +647,7 @@ module Daru
     #   a.splitted
     #     =>
     #   [["a","b"],["c","d"],["a","b"],["d"]]
-    def splitted sep=","
+    def splitted sep=','
       @data.map do |s|
         if s.nil?
           nil
@@ -708,14 +672,11 @@ module Daru
     #      "c"=>#<Daru::Vector:0x7f2dbcc09b08
     #        @data=[0, 1, 1]>}
     #
-    def split_by_separator sep=","
+    def split_by_separator sep=','
       split_data = splitted sep
       factors = split_data.flatten.uniq.compact
 
-      out = factors.inject({}) do |h,x|
-        h[x] = []
-        h
-      end
+      out = factors.map { |x| [x, []] }.to_h
 
       split_data.each do |r|
         if r.nil?
@@ -724,22 +685,18 @@ module Daru
           end
         else
           factors.each do |f|
-            out[f].push(r.include?(f) ? 1:0)
+            out[f].push(r.include?(f) ? 1 : 0)
           end
         end
       end
 
-      out.inject({}) do |s,v|
-        s[v[0]] = Daru::Vector.new v[1]
-        s
-      end
+      out.map { |k, v| [k, Daru::Vector.new(v)] }.to_h
     end
 
-    def split_by_separator_freq(sep=",")
-      split_by_separator(sep).inject({}) do |a,v|
-        a[v[0]] = v[1].inject { |s,x| s+x.to_i }
-        a
-      end
+    def split_by_separator_freq(sep=',')
+      split_by_separator(sep).map do |k, v|
+        [k, v.inject { |s,x| s+x.to_i }]
+      end.to_h
     end
 
     def reset_index!
@@ -808,25 +765,25 @@ module Daru
     #   ts.lag   # => [nil, 0.69, 0.23, 0.44, ...]
     #   ts.lag(2) # => [nil, nil, 0.69, 0.23, ...]
     def lag k=1
-      return self.dup if k == 0
+      return dup if k == 0
 
       dat = @data.to_a.dup
       (dat.size - 1).downto(k) { |i| dat[i] = dat[i - k] }
       (0...k).each { |i| dat[i] = nil }
 
-      Daru::Vector.new(dat, index: @index, name: @name)
+      Daru::Vector.new(dat, index: @index, name: @name, metadata: @metadata.dup)
     end
 
     def detach_index
-      Daru::DataFrame.new({
+      Daru::DataFrame.new(
         index: @index.to_a,
         values: @data.to_a
-      })
+      )
     end
 
     # Non-destructive version of #replace_nils!
     def replace_nils replacement
-      self.dup.replace_nils!(replacement)
+      dup.replace_nils!(replacement)
     end
 
     # number of non-missing elements
@@ -857,23 +814,13 @@ module Daru
     # If dtype != gsl, will convert data to GSL::Vector with to_a. Otherwise returns
     # the stored GSL::Vector object.
     def to_gsl
-      if Daru.has_gsl?
-        if dtype == :gsl
-          return @data.data
-        else
-          GSL::Vector.alloc only_valid(:array).to_a
-        end
-      else
-        raise NoMethodError, "Install gsl-nmatrix for access to this functionality."
-      end
+      raise NoMethodError, 'Install gsl-nmatrix for access to this functionality.' unless Daru.has_gsl?
+      dtype == :gsl ? @data.data : GSL::Vector.alloc(only_valid(:array).to_a)
     end
 
-    # Convert to hash. Hash keys are indexes and values are the correspoding elements
-    def to_hash
-      @index.inject({}) do |hsh, index|
-        hsh[index] = self[index]
-        hsh
-      end
+    # Convert to hash (explicit). Hash keys are indexes and values are the correspoding elements
+    def to_h
+      @index.map { |index| [index, self[index]] }.to_h
     end
 
     # Return an array
@@ -881,34 +828,33 @@ module Daru
       @data.to_a
     end
 
-    # Convert the hash from to_hash to json
-    def to_json *args
-      self.to_hash.to_json
+    # Convert the hash from to_h to json
+    def to_json(*)
+      to_h.to_json
     end
 
     # Convert to html for iruby
     def to_html threshold=30
       name = @name || 'nil'
-      html = "<table>" +
-        "<tr>" +
-          "<th colspan=\"2\">" +
-            "Daru::Vector:#{self.object_id} " + " size: #{size}" +
-          "</th>" +
-        "</tr>"
+      html = '<table>' \
+        '<tr>' \
+          '<th colspan="2">' \
+            "Daru::Vector:#{object_id} " + " size: #{size}" \
+          '</th>' \
+        '</tr>'
       html += '<tr><th> </th><th>' + name.to_s + '</th></tr>'
       @index.each_with_index do |index, num|
         html += '<tr><td>' + index.to_s + '</td>' + '<td>' + self[index].to_s + '</td></tr>'
 
-        if num > threshold
-          html += '<tr><td>...</td><td>...</td></tr>'
+        next if num <= threshold
+        html += '<tr><td>...</td><td>...</td></tr>'
 
-          last_index = @index.to_a.last
-          html += '<tr>' +
-                    '<td>' + last_index.to_s       + '</td>' +
-                    '<td>' + self[last_index].to_s + '</td>' +
-                  '</tr>'
-          break
-        end
+        last_index = @index.to_a.last
+        html += '<tr>' \
+                  '<td>' + last_index.to_s       + '</td>' \
+                  '<td>' + self[last_index].to_s + '</td>' \
+                '</tr>'
+        break
       end
       html += '</table>'
 
@@ -920,34 +866,34 @@ module Daru
     end
 
     # Create a summary of the Vector using Report Builder.
-    def summary(method = :to_text)
+    def summary(method=:to_text)
       ReportBuilder.new(no_title: true).add(self).send(method)
     end
 
     def report_building b
-      b.section(:name => name) do |s|
+      b.section(name: name) do |s|
         s.text "n :#{size}"
         s.text "n valid:#{n_valid}"
         if @type == :object
           s.text  "factors: #{factors.to_a.join(',')}"
           s.text  "mode: #{mode}"
 
-          s.table(:name => "Distribution") do |t|
-            frequencies.sort_by { |a| a.to_s }.each do |k,v|
+          s.table(name: 'Distribution') do |t|
+            frequencies.sort_by(&:to_s).each do |k,v|
               key = @index.include?(k) ? @index[k] : k
-              t.row [key, v , ("%0.2f%%" % (v.quo(n_valid)*100))]
+              t.row [key, v, ('%0.2f%%' % (v.quo(n_valid)*100))]
             end
           end
         end
 
-        s.text "median: #{median.to_s}" if (@type==:numeric or @type==:numeric)
+        s.text "median: #{median}" if @type==:numeric || @type==:numeric
         if @type==:numeric
-          s.text "mean: %0.4f" % mean
+          s.text 'mean: %0.4f' % mean
           if sd
-            s.text "std.dev.: %0.4f" % sd
-            s.text "std.err.: %0.4f" % se
-            s.text "skew: %0.4f" % skew
-            s.text "kurtosis: %0.4f" % kurtosis
+            s.text 'std.dev.: %0.4f' % sd
+            s.text 'std.err.: %0.4f' % se
+            s.text 'skew: %0.4f' % skew
+            s.text 'kurtosis: %0.4f' % kurtosis
           end
         end
       end
@@ -955,22 +901,26 @@ module Daru
 
     # Over rides original inspect for pretty printing in irb
     def inspect spacing=20, threshold=15
-      longest = [@name.to_s.size,
-                 (@index.to_a.map(&:to_s).map(&:size).max || 0),
-                 (@data    .map(&:to_s).map(&:size).max || 0),
-                 'nil'.size].max
-
-      content   = ""
+      longest =
+        [
+          @name.to_s.size,
+          (@index.to_a.map(&:to_s).map(&:size).max || 0),
+          (@data.map(&:to_s).map(&:size).max || 0),
+          3 # 'nil'.size
+        ].max
+
+      content   = ''
       longest   = spacing if longest > spacing
       name      = @name || 'nil'
+      metadata  = @metadata || 'nil'
       formatter = "\n%#{longest}.#{longest}s %#{longest}.#{longest}s"
-      content  += "\n#<" + self.class.to_s + ":" + self.object_id.to_s + " @name = " + name.to_s + " @size = " + size.to_s + " >"
+      content  += "\n#<#{self.class}:#{object_id} @name = #{name} @metadata = #{metadata} @size = #{size} >"
 
-      content += sprintf formatter, "", name
+      content += formatter % ['', name]
       @index.each_with_index do |index, num|
-        content += sprintf formatter, index.to_s, (self[*index] || 'nil').to_s
+        content += formatter % [index.to_s, (self[*index] || 'nil').to_s]
         if num > threshold
-          content += sprintf formatter, '...', '...'
+          content += formatter % ['...', '...']
           break
         end
       end
@@ -982,14 +932,10 @@ module Daru
     # Create a new vector with a different index, and preserve the indexing of
     # current elements.
     def reindex new_index
-      vector = Daru::Vector.new([], index: new_index, name: @name)
+      vector = Daru::Vector.new([], index: new_index, name: @name, metadata: @metadata.dup)
 
       new_index.each do |idx|
-        if @index.include?(idx)
-          vector[idx] = self[idx]
-        else
-          vector[idx] = nil
-        end
+        vector[idx] = @index.include?(idx) ? self[idx] : nil
       end
 
       vector
@@ -998,9 +944,9 @@ module Daru
     def index= idx
       raise ArgumentError,
         "Size of supplied index #{index.size} does not match size of DataFrame" if
-        idx.size != self.size
-      raise ArgumentError, "Can only assign type Index and its subclasses." unless
-        idx.kind_of?(Daru::Index)
+        idx.size != size
+      raise ArgumentError, 'Can only assign type Index and its subclasses.' unless
+        idx.is_a?(Daru::Index)
 
       @index = idx
       self
@@ -1020,7 +966,7 @@ module Daru
 
     # Duplicate elements and indexes
     def dup
-      Daru::Vector.new @data.dup, name: @name, index: @index.dup
+      Daru::Vector.new @data.dup, name: @name, metadata: @metadata.dup, index: @index.dup
     end
 
     # == Bootstrap
@@ -1042,7 +988,7 @@ module Daru
       s ||= size
       h_est, es, bss = prepare_bootstrap(estimators)
 
-      nr.times do |i|
+      nr.times do
         bs = sample_with_replacement(s)
         es.each do |estimator|
           bss[estimator].push(h_est[estimator].call(bs))
@@ -1079,10 +1025,7 @@ module Daru
       nb = (size / k).to_i
       h_est, es, ps = prepare_bootstrap(estimators)
 
-      est_n = es.inject({}) do |h,v|
-        h[v] = h_est[v].call(self)
-        h
-      end
+      est_n = es.map { |v| [v, h_est[v].call(self)] }.to_h
 
       nb.times do |i|
         other = @data.dup
@@ -1092,7 +1035,8 @@ module Daru
         es.each do |estimator|
           # Add pseudovalue
           ps[estimator].push(
-            nb * est_n[estimator] - (nb-1) * h_est[estimator].call(other))
+            nb * est_n[estimator] - (nb-1) * h_est[estimator].call(other)
+          )
         end
       end
 
@@ -1114,9 +1058,9 @@ module Daru
     # Otherwise, a duplicate will be returned irrespective of
     # presence of missing data.
     def only_valid as_a=:vector, duplicate=true
-      return self.dup if !has_missing_data? and as_a == :vector and duplicate
-      return self if !has_missing_data? and as_a == :vector and !duplicate
-      return self.to_a if !has_missing_data? and as_a != :vector
+      return dup if !has_missing_data? && as_a == :vector && duplicate
+      return self if !has_missing_data? && as_a == :vector && !duplicate
+      return to_a if !has_missing_data? && as_a != :vector
 
       new_index = @index.to_a - missing_positions
       new_vector = new_index.map do |idx|
@@ -1125,7 +1069,7 @@ module Daru
 
       return new_vector if as_a != :vector
 
-      Daru::Vector.new new_vector, index: new_index, name: @name, dtype: dtype
+      Daru::Vector.new new_vector, index: new_index, name: @name, metadata: @metadata.dup, dtype: dtype
     end
 
     # Returns a Vector containing only missing data (preserves indexes).
@@ -1143,30 +1087,32 @@ module Daru
       numeric_indexes = []
 
       each_with_index do |v, i|
-        numeric_indexes << i if(v.kind_of?(Numeric) or @missing_values.has_key?(v))
+        numeric_indexes << i if v.is_a?(Numeric) || @missing_values.key?(v)
       end
 
       self[*numeric_indexes]
     end
 
     # Returns the database type for the vector, according to its content
-    def db_type(dbs=:mysql)
+    def db_type
       # first, detect any character not number
-      if @data.find {|v| v.to_s=~/\d{2,2}-\d{2,2}-\d{4,4}/} or @data.find {|v| v.to_s=~/\d{4,4}-\d{2,2}-\d{2,2}/}
-        return "DATE"
-      elsif @data.find {|v|  v.to_s=~/[^0-9e.-]/ }
-        return "VARCHAR (255)"
-      elsif @data.find {|v| v.to_s=~/\./}
-        return "DOUBLE"
+      if @data.find { |v| v.to_s=~/\d{2,2}-\d{2,2}-\d{4,4}/ } ||
+         @data.find { |v| v.to_s=~/\d{4,4}-\d{2,2}-\d{2,2}/ }
+
+        return 'DATE'
+      elsif @data.find { |v| v.to_s=~/[^0-9e.-]/ }
+        return 'VARCHAR (255)'
+      elsif @data.find { |v| v.to_s=~/\./ }
+        return 'DOUBLE'
       else
-        return "INTEGER"
+        return 'INTEGER'
       end
     end
 
     # Copies the structure of the vector (i.e the index, size, etc.) and fills all
     # all values with nils.
     def clone_structure
-      Daru::Vector.new(([nil]*@size), name: @name, index: @index.dup)
+      Daru::Vector.new(([nil]*@size), name: @name, metadata: @metadata.dup, index: @index.dup)
     end
 
     # Save the vector to a file
@@ -1178,29 +1124,33 @@ module Daru
       Daru::IO.save self, filename
     end
 
-    def _dump(depth) # :nodoc:
-      Marshal.dump({
-        data:  @data.to_a,
-        dtype: @dtype,
-        name:  @name,
-        index: @index,
-        missing_values: @missing_values})
+    def _dump(*) # :nodoc:
+      Marshal.dump(
+        data:           @data.to_a,
+        dtype:          @dtype,
+        name:           @name,
+        metadata:       @metadata,
+        index:          @index,
+        missing_values: @missing_values
+      )
     end
 
     def self._load(data) # :nodoc:
       h = Marshal.load(data)
-      Daru::Vector.new(h[:data], index: h[:index],
-        name: h[:name], dtype: h[:dtype], missing_values: h[:missing_values])
+      Daru::Vector.new(h[:data],
+        index: h[:index],
+        name: h[:name], metadata: h[:metadata],
+        dtype: h[:dtype], missing_values: h[:missing_values])
     end
 
-    def daru_vector *name
+    def daru_vector(*)
       self
     end
 
     alias :dv :daru_vector
 
     def method_missing(name, *args, &block)
-      if name.match(/(.+)\=/)
+      if name =~ /(.+)\=/
         self[name] = args[0]
       elsif has_index?(name)
         self[name]
@@ -1209,7 +1159,7 @@ module Daru
       end
     end
 
-   private
+    private
 
     # For an array or hash of estimators methods, returns
     # an array with three elements
@@ -1218,71 +1168,20 @@ module Daru
     # 3.- A Hash with estimators names as keys and empty arrays as values
     def prepare_bootstrap(estimators)
       h_est = estimators
-      h_est = [h_est] unless h_est.is_a?(Array) or h_est.is_a?(Hash)
+      h_est = [h_est] unless h_est.is_a?(Array) || h_est.is_a?(Hash)
 
       if h_est.is_a? Array
-        h_est = h_est.inject({}) do |h, est|
-          h[est] = lambda { |v| Daru::Vector.new(v).send(est) }
-          h
-        end
+        h_est = h_est.map do |est|
+          [est, ->(v) { Daru::Vector.new(v).send(est) }]
+        end.to_h
       end
-      bss = h_est.keys.inject({}) { |h,v| h[v] = []; h }
+      bss = h_est.keys.map { |v| [v, []] }.to_h
 
       [h_est, h_est.keys, bss]
     end
 
-    def quick_sort vector, index, order, &block
-      recursive_quick_sort vector, index, order, 0, @size-1, &block
-      [vector, index]
-    end
-
-    def recursive_quick_sort vector, index, order, left_lower, right_upper, &block
-      if left_lower < right_upper
-        left_upper, right_lower = partition(vector, index, order, left_lower, right_upper, &block)
-        if left_upper - left_lower < right_upper - right_lower
-          recursive_quick_sort(vector, index, order, left_lower, left_upper, &block)
-          recursive_quick_sort(vector, index, order, right_lower, right_upper, &block)
-        else
-          recursive_quick_sort(vector, index, order, right_lower, right_upper, &block)
-          recursive_quick_sort(vector, index, order, left_lower, left_upper, &block)
-        end
-      end
-    end
-
-    def partition vector, index, order, left_lower, right_upper, &block
-      mindex = (left_lower + right_upper) / 2
-      mvalue = vector[mindex]
-      i = left_lower
-      j = right_upper
-      opposite_order = order == :ascending ? :descending : :ascending
-
-      i += 1 while(keep?(vector[i], mvalue, order, &block))
-      j -= 1 while(keep?(vector[j], mvalue, opposite_order, &block))
-
-      while i < j - 1
-        vector[i], vector[j] = vector[j], vector[i]
-        index[i], index[j]   = index[j], index[i]
-        i += 1
-        j -= 1
-
-        i += 1 while(keep?(vector[i], mvalue, order, &block))
-        j -= 1 while(keep?(vector[j], mvalue, opposite_order, &block))
-      end
-
-      if i <= j
-        if i < j
-          vector[i], vector[j] = vector[j], vector[i]
-          index[i], index[j]   = index[j], index[i]
-        end
-        i += 1
-        j -= 1
-      end
-
-      [j,i]
-    end
-
-    def keep? a, b, order, &block
-      eval = block.call(a,b)
+    def keep? a, b, order
+      eval = yield(a, b)
       if order == :ascending
         return true  if eval == -1
         return false if eval == 1
@@ -1290,7 +1189,7 @@ module Daru
         return false if eval == -1
         return true  if eval == 1
       end
-      return false
+      false
     end
 
     # Note: To maintain sanity, this _MUST_ be the _ONLY_ place in daru where the
@@ -1299,28 +1198,18 @@ module Daru
       source = @data.to_a if source.nil?
 
       new_vector =
-      case dtype
-      when :array   then Daru::Accessors::ArrayWrapper.new(source, self)
-      when :nmatrix then Daru::Accessors::NMatrixWrapper.new(source, self, nm_dtype)
-      when :gsl then Daru::Accessors::GSLWrapper.new(source, self)
-      when :mdarray then raise NotImplementedError, "MDArray not yet supported."
-      else raise "Unknown dtype #{dtype}"
-      end
+        case dtype
+        when :array   then Daru::Accessors::ArrayWrapper.new(source, self)
+        when :nmatrix then Daru::Accessors::NMatrixWrapper.new(source, self, nm_dtype)
+        when :gsl then Daru::Accessors::GSLWrapper.new(source, self)
+        when :mdarray then raise NotImplementedError, 'MDArray not yet supported.'
+        else raise "Unknown dtype #{dtype}"
+        end
 
       @dtype = dtype || :array
       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]
@@ -1333,25 +1222,25 @@ module Daru
       @size = @data.size
     end
 
-    def set_name name
+    def set_name name # rubocop:disable Style/AccessorMethodName
       @name =
-      if name.is_a?(Numeric)  then name
-      elsif name.is_a?(Array) then name.join # in case of MultiIndex tuple
-      elsif name              then name # anything but Numeric or nil
-      else
-        nil
-      end
+        if name.is_a?(Numeric)  then name
+        elsif name.is_a?(Array) then name.join # in case of MultiIndex tuple
+        elsif name              then name # anything but Numeric or nil
+        else
+          nil
+        end
     end
 
     def set_missing_positions
       @missing_positions = []
       @index.each do |e|
-        @missing_positions << e if (@missing_values.has_key?(self[e]))
+        @missing_positions << e if @missing_values.key?(self[e])
       end
     end
 
     def try_create_index potential_index
-      if potential_index.is_a?(Daru::MultiIndex) or potential_index.is_a?(Daru::Index)
+      if potential_index.is_a?(Daru::MultiIndex) || potential_index.is_a?(Daru::Index)
         potential_index
       else
         Daru::Index.new(potential_index)
@@ -1365,11 +1254,13 @@ module Daru
 
     # Setup missing_values. The missing_values instance variable is set
     # as a Hash for faster lookup times.
-    def set_missing_values values_arry
+    def set_missing_values values_arry # rubocop:disable Style/AccessorMethodName
       @missing_values = {}
       @missing_values[nil] = 0
       if values_arry
         values_arry.each do |e|
+          # If dtype is :gsl then missing values have to be converted to float
+          e = e.to_f if dtype == :gsl && e.is_a?(Numeric)
           @missing_values[e] = 0
         end
       end