daru 0.1.5 → 0.3

data/lib/daru/plotting/gruff/dataframe.rb

@@ -7,12 +7,12 @@ module Daru
           size = opts[:size] || 500
           x = extract_x_vector opts[:x]
           y = extract_y_vectors opts[:y]
-          if opts[:categorized]
-            return plot_with_category(size, type, x, y, opts[:categorized])
-          end
+          type = process_type type, opts[:categorized]
           case type
           when :line, :bar, :scatter
             plot = send("#{type}_plot", size, x, y)
+          when :scatter_categorized
+            plot = scatter_with_category(size, x, y, opts[:categorized])
           # TODO: hist, box
           # It turns out hist and box are not supported in Gruff yet
           else
@@ -24,6 +24,10 @@ module Daru
 
         private
 
+        def process_type type, categorized
+          type == :scatter && categorized ? :scatter_categorized : type
+        end
+
         def line_plot size, x, y
           plot = Gruff::Line.new size
           plot.labels = size.times.to_a.zip(x).to_h
@@ -50,21 +54,15 @@ module Daru
           plot
         end
 
-        def plot_with_category size, type, x, y, opts
+        def scatter_with_category size, x, y, opts
           x = Daru::Vector.new x
           y = y.first
-          case type
-          when :scatter
-            plot = Gruff::Scatter.new size
-            cat_dv = self[opts[:by]]
-            cat_dv.categories.each do |cat|
-              bools = cat_dv.eq cat
-              plot.data cat, x.where(bools).to_a, y.where(bools).to_a
-            end
-          else
-            raise ArgumentError, "Type #{type} is not supported."
+          plot = Gruff::Scatter.new size
+          cat_dv = self[opts[:by]]
+          cat_dv.categories.each do |cat|
+            bools = cat_dv.eq cat
+            plot.data cat, x.where(bools).to_a, y.where(bools).to_a
           end
-          yield plot if block_given?
           plot
         end
 

data/lib/daru/plotting/nyaplot/category.rb

@@ -12,7 +12,7 @@ module Daru
             # Set yrange for good view
             set_yrange plot, opts[:method]
             yield plot, diagram if block_given?
-            plot.show
+            plot
           else
             raise ArgumentError, "#{type} type is not supported."
           end

data/lib/daru/plotting/nyaplot/dataframe.rb

@@ -21,6 +21,8 @@ module Daru
         #   df = Daru::DataFrame.new({a:['A', 'B', 'C', 'D', 'E'], b:[10,20,30,40,50]})
         #   df.plot type: :bar, x: :a, y: :b
         def plot opts={}, &block
+          index_as_default_x_axis(opts) unless x_axis_defined?(opts)
+
           if opts[:categorized]
             plot_with_category(opts, &block)
           else
@@ -30,6 +32,15 @@ module Daru
 
         private
 
+        def x_axis_defined?(opts)
+          opts[:x] || opts.keys.any? { |k| k.to_s.match(/x\d+/) }
+        end
+
+        def index_as_default_x_axis(opts)
+          opts[:x]      = :_index
+          self[:_index] = @index.to_a
+        end
+
         def plot_without_category opts
           options = {type: :scatter}.merge(opts)
 
@@ -38,7 +49,7 @@ module Daru
 
           diagram =
             case
-            when !([:scatter, :bar, :line, :histogram] & types).empty?
+            when !(%i[scatter bar line histogram] & types).empty?
               plot_regular_diagrams plot, opts
             when types.include?(:box)
               plot_box_diagram plot
@@ -48,7 +59,7 @@ module Daru
 
           yield(plot, diagram) if block_given?
 
-          plot.show
+          plot
         end
 
         def plot_with_category opts
@@ -66,8 +77,8 @@ module Daru
 
             plot.legend true
             yield plot, *diagrams if block_given?
-            plot.show
 
+            plot
           else
             raise ArgumentError, "Unsupported type #{type}"
           end
@@ -102,7 +113,7 @@ module Daru
           end
         end
 
-        SHAPES = %w(circle triangle-up diamond square triangle-down cross).freeze
+        SHAPES = %w[circle triangle-up diamond square triangle-down cross].freeze
         def get_shape type
           validate_type type, :scatter
           SHAPES.cycle

data/lib/daru/plotting/nyaplot/vector.rb

@@ -26,8 +26,7 @@ module Daru
           diagram = create_diagram plot, options[:type], x_axis
 
           yield plot, diagram if block_given?
-
-          plot.show
+          plot
         end
 
         private

data/lib/daru/vector.rb

@@ -122,6 +122,17 @@ module Daru
       self
     end
 
+    def apply_method(method, keys: nil, by_position: true)
+      vect = keys ? get_sub_vector(keys, by_position: by_position) : self
+
+      case method
+      when Symbol then vect.send(method)
+      when Proc   then method.call(vect)
+      else raise
+      end
+    end
+    alias :apply_method_on_sub_vector :apply_method
+
     # The name of the Daru::Vector. String.
     attr_reader :name
     # The row index. Can be either Daru::Index or Daru::MultiIndex.
@@ -140,8 +151,6 @@ module Daru
     attr_accessor :labels
     # Store vector data in an array
     attr_reader :data
-    # Ploting library being used for this vector
-    attr_reader :plotting_library
     # TODO: Make private.
     attr_reader :nil_positions, :nan_positions
 
@@ -186,6 +195,13 @@ module Daru
       end
     end
 
+    # attr_reader for :plotting_library
+    def plotting_library
+      init_plotting_library
+
+      @plotting_library
+    end
+
     def plotting_library= lib
       case lib
       when :gruff, :nyaplot
@@ -196,11 +212,18 @@ module Daru
           )
         end
       else
-        raise ArguementError, "Plotting library #{lib} not supported. "\
+        raise ArgumentError, "Plotting library #{lib} not supported. "\
           'Supported libraries are :nyaplot and :gruff'
       end
     end
 
+    # this method is overwritten: see Daru::Vector#plotting_library=
+    def plot(*args, **options, &b)
+      init_plotting_library
+
+      plot(*args, **options, &b)
+    end
+
     # Get one or more elements with specified index or a range.
     #
     # == Usage
@@ -228,7 +251,7 @@ module Daru
     end
 
     # Returns vector of values given positional values
-    # @param [Array<object>] *positions positional values
+    # @param positions [Array<object>] positional values
     # @return [object] vector
     # @example
     #   dv = Daru::Vector.new 'a'..'e'
@@ -252,7 +275,7 @@ module Daru
     end
 
     # Change value at given positions
-    # @param [Array<object>] *positions positional values
+    # @param positions [Array<object>] positional values
     # @param [object] val value to assign
     # @example
     #   dv = Daru::Vector.new 'a'..'e'
@@ -352,7 +375,7 @@ module Daru
         if other.is_a?(Daru::Vector)
           mod.apply_vector_operator operator, self, other
         else
-          mod.apply_scalar_operator operator, @data,other
+          mod.apply_scalar_operator operator, @data, other
         end
       end
       alias_method operator, method if operator != :== && operator != :!=
@@ -385,11 +408,11 @@ module Daru
     # comparator methods to obtain meaningful results. See this notebook for
     # a good overview of using #where.
     #
-    # @param [Daru::Core::Query::BoolArray, Array<TrueClass, FalseClass>] bool_arry The
+    # @param bool_array [Daru::Core::Query::BoolArray, Array<TrueClass, FalseClass>] The
     #   collection containing the true of false values. Each element in the Vector
     #   corresponding to a `true` in the bool_arry will be returned alongwith it's
     #   index.
-    # @exmaple Usage of #where.
+    # @example Usage of #where.
     #   vector = Daru::Vector.new([2,4,5,51,5,16,2,5,3,2,1,5,2,5,2,1,56,234,6,21])
     #
     #   # Simple logic statement passed to #where.
@@ -421,6 +444,27 @@ module Daru
       Daru::Core::Query.vector_where self, bool_array
     end
 
+    # Return a new vector based on the contents of a boolean array and &block.
+    #
+    # @param bool_array [Daru::Core::Query::BoolArray, Array<TrueClass, FalseClass>, &block] The
+    #   collection containing the true of false values. Each element in the Vector
+    #   corresponding to a `true` in the bool_array will be returned along with it's
+    #   index. The &block may contain manipulative functions for the Vector elements.
+    #
+    # @return [Daru::Vector]
+    #
+    # @example Usage of #apply_where.
+    #   dv = Daru::Vector.new ['3 days', '5 weeks', '2 weeks']
+    #   dv = dv.apply_where(dv.match /weeks/) { |x| "#{x.split.first.to_i * 7} days" }
+    #   # =>
+    #   ##<Daru::Vector(3)>
+    #   #  0   3 days
+    #   #  1   35 days
+    #   #  2   14 days
+    def apply_where bool_array, &block
+      Daru::Core::Query.vector_apply_where self, bool_array, &block
+    end
+
     def head q=10
       self[0..(q-1)]
     end
@@ -430,6 +474,11 @@ module Daru
       self[start..(size-1)]
     end
 
+    def last q=1
+      # The Enumerable mixin dose not provide the last method.
+      tail(q)
+    end
+
     def empty?
       @index.empty?
     end
@@ -451,7 +500,7 @@ module Daru
     deprecate :flawed?, :include_values?, 2016, 10
 
     # Check if any one of mentioned values occur in the vector
-    # @param [Array] *values values to check for
+    # @param values  [Array] values to check for
     # @return [true, false] returns true if any one of specified values
     #   occur in the vector
     # @example
@@ -462,6 +511,26 @@ module Daru
       values.any? { |v| include_with_nan? @data, v }
     end
 
+    # @note Do not use it to check for Float::NAN as
+    #   Float::NAN == Float::NAN is false
+    # Return vector of booleans with value at ith position is either
+    # true or false depending upon whether value at position i is equal to
+    # any of the values passed in the argument or not
+    # @param values [Array] values to equate with
+    # @return [Daru::Vector] vector of boolean values
+    # @example
+    #   dv = Daru::Vector.new [1, 2, 3, 2, 1]
+    #   dv.is_values 1, 2
+    #   # => #<Daru::Vector(5)>
+    #   #     0  true
+    #   #     1  true
+    #   #     2 false
+    #   #     3  true
+    #   #     4  true
+    def is_values(*values)
+      Daru::Vector.new values.map { |v| eq(v) }.inject(:|)
+    end
+
     # 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
@@ -481,8 +550,7 @@ module Daru
     # * +:dtype+ - :array for Ruby Array. :nmatrix for NMatrix.
     def cast opts={}
       dt = opts[:dtype]
-      raise ArgumentError, "Unsupported dtype #{opts[:dtype]}" unless
-        dt == :array || dt == :nmatrix || dt == :gsl
+      raise ArgumentError, "Unsupported dtype #{opts[:dtype]}" unless %i[array nmatrix gsl].include?(dt)
 
       @data = cast_vector_to dt unless @dtype == dt
     end
@@ -535,7 +603,7 @@ module Daru
     # Get index of element
     def index_of element
       case dtype
-      when :array then @index.key @data.index { |x| x.eql? element }
+      when :array then @index.key(@data.index { |x| x.eql? element })
       else @index.key @data.index(element)
       end
     end
@@ -583,6 +651,31 @@ module Daru
       Daru::Vector.new(vector, index: index, name: @name, dtype: @dtype)
     end
 
+    # Sorts the vector according to it's`Index` values. Defaults to ascending
+    # order sorting.
+    #
+    # @param [Hash] opts the options for sort_by_index method.
+    # @option opts [Boolean] :ascending false, will sort `index` in
+    #  descending order.
+    #
+    # @return [Vector] new sorted `Vector` according to the index values.
+    #
+    # @example
+    #
+    #   dv = Daru::Vector.new [11, 13, 12], index: [23, 21, 22]
+    #   # Say you want to sort index in ascending order
+    #   dv.sort_by_index(ascending: true)
+    #   #=> Daru::Vector.new [13, 12, 11], index: [21, 22, 23]
+    #   # Say you want to sort index in descending order
+    #   dv.sort_by_index(ascending: false)
+    #   #=> Daru::Vector.new [11, 12, 13], index: [23, 22, 21]
+    def sort_by_index opts={}
+      opts = {ascending: true}.merge(opts)
+      _, new_order = resort_index(@index.each_with_index, opts).transpose
+
+      reorder new_order
+    end
+
     DEFAULT_SORTER = lambda { |(lv, li), (rv, ri)|
       case
       when lv.nil? && rv.nil?
@@ -624,7 +717,7 @@ module Daru
     def delete_if
       return to_enum(:delete_if) unless block_given?
 
-      keep_e, keep_i = each_with_index.select { |n, _i| !yield(n) }.transpose
+      keep_e, keep_i = each_with_index.reject { |n, _i| yield(n) }.transpose
 
       @data = cast_vector_to @dtype, keep_e
       @index = Daru::Index.new(keep_i)
@@ -702,31 +795,6 @@ module Daru
       self
     end
 
-    # Returns a vector which has *true* in the position where the element in self
-    # is nil, and false otherwise.
-    #
-    # == Usage
-    #
-    #   v = Daru::Vector.new([1,2,4,nil])
-    #   v.is_nil?
-    #   # =>
-    #   #<Daru::Vector:89421000 @name = nil @size = 4 >
-    #   #      nil
-    #   #  0  false
-    #   #  1  false
-    #   #  2  false
-    #   #  3  true
-    #
-    def is_nil?
-      # FIXME: EXTREMELY bad name for method not returning boolean - zverok, 2016-05-18
-      recode(&:nil?)
-    end
-
-    # Opposite of #is_nil?
-    def not_nil?
-      recode { |v| !v.nil? }
-    end
-
     # Replace all nils in the vector with the value passed as an argument. Destructive.
     # See #replace_nils for non-destructive version
     #
@@ -741,27 +809,81 @@ module Daru
       self
     end
 
-    # Lags the series by k periods.
+    # Rolling fillna
+    # replace all Float::NAN and NIL values with the preceeding or following value
     #
-    # The convention is to set the oldest observations (the first ones
-    # in the series) to nil so that the size of the lagged series is the
-    # same as the original.
+    # @param direction [Symbol] (:forward, :backward) whether replacement value is preceeding or following
     #
-    # Usage:
+    # @example
+    #  dv = Daru::Vector.new([1, 2, 1, 4, nil, Float::NAN, 3, nil, Float::NAN])
     #
-    #   ts = Daru::Vector.new((1..10).map { rand })
-    #           # => [0.69, 0.23, 0.44, 0.71, ...]
+    #   2.3.3 :068 > dv.rolling_fillna(:forward)
+    #   => #<Daru::Vector(9)>
+    #   0   1
+    #   1   2
+    #   2   1
+    #   3   4
+    #   4   4
+    #   5   4
+    #   6   3
+    #   7   3
+    #   8   3
     #
-    #   ts.lag   # => [nil, 0.69, 0.23, 0.44, ...]
-    #   ts.lag(2) # => [nil, nil, 0.69, 0.23, ...]
-    def lag k=1
-      return dup if k.zero?
+    def rolling_fillna!(direction=:forward)
+      enum = direction == :forward ? index : index.reverse_each
+      last_valid_value = 0
+      enum.each do |idx|
+        if valid_value?(self[idx])
+          last_valid_value = self[idx]
+        else
+          self[idx] = last_valid_value
+        end
+      end
+      self
+    end
 
-      dat = @data.to_a.dup
-      (dat.size - 1).downto(k) { |i| dat[i] = dat[i - k] }
-      (0...k).each { |i| dat[i] = nil }
+    # Non-destructive version of rolling_fillna!
+    def rolling_fillna(direction=:forward)
+      dup.rolling_fillna!(direction)
+    end
 
-      Daru::Vector.new(dat, index: @index, name: @name)
+    # Lags the series by `k` periods.
+    #
+    # Lags the series by `k` periods, "shifting" data and inserting `nil`s
+    # from beginning or end of a vector, while preserving original vector's
+    # size.
+    #
+    # `k` can be positive or negative integer. If `k` is positive, `nil`s
+    # are inserted at the beginning of the vector, otherwise they are
+    # inserted at the end.
+    #
+    # @param [Integer] k "shift" the series by `k` periods. `k` can be
+    #   positive or negative. (default = 1)
+    #
+    # @return [Daru::Vector] a new vector with "shifted" inital values
+    #   and `nil` values inserted. The return vector is the same length
+    #   as the orignal vector.
+    #
+    # @example Lag a vector with different periods `k`
+    #
+    #   ts = Daru::Vector.new(1..5)
+    #               # => [1, 2, 3, 4, 5]
+    #
+    #   ts.lag      # => [nil, 1, 2, 3, 4]
+    #   ts.lag(1)   # => [nil, 1, 2, 3, 4]
+    #   ts.lag(2)   # => [nil, nil, 1, 2, 3]
+    #   ts.lag(-1)  # => [2, 3, 4, 5, nil]
+    #
+    def lag k=1
+      case k
+      when 0 then dup
+      when 1...size
+        copy([nil] * k + data.to_a)
+      when -size..-1
+        copy(data.to_a[k.abs...size])
+      else
+        copy([])
+      end
     end
 
     def detach_index
@@ -783,7 +905,7 @@ module Daru
     deprecate :n_valid, :count_values, 2016, 10
 
     # Count the number of values specified
-    # @param [Array] *values values to count for
+    # @param values [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]
@@ -798,6 +920,19 @@ module Daru
       @index.include? index
     end
 
+    # @param keys [Array] can be positions (if by_position is true) or indexes (if by_position if false)
+    # @return [Daru::Vector]
+    def get_sub_vector(keys, by_position: true)
+      return Daru::Vector.new([]) if keys == []
+
+      keys = @index.pos(*keys) unless by_position
+
+      sub_vect = at(*keys)
+      sub_vect = Daru::Vector.new([sub_vect]) unless sub_vect.is_a?(Daru::Vector)
+
+      sub_vect
+    end
+
     # @return [Daru::DataFrame] the vector as a single-vector dataframe
     def to_df
       Daru::DataFrame.new({@name => @data}, name: @name, index: @index)
@@ -871,7 +1006,9 @@ module Daru
     end
 
     # Convert to html for iruby
-    def to_html threshold=30
+    def to_html(threshold=30)
+      table_thead = to_html_thead
+      table_tbody = to_html_tbody(threshold)
       path = if index.is_a?(MultiIndex)
                File.expand_path('../iruby/templates/vector_mi.html.erb', __FILE__)
              else
@@ -880,51 +1017,97 @@ module Daru
       ERB.new(File.read(path).strip).result(binding)
     end
 
+    def to_html_thead
+      table_thead_path =
+        if index.is_a?(MultiIndex)
+          File.expand_path('../iruby/templates/vector_mi_thead.html.erb', __FILE__)
+        else
+          File.expand_path('../iruby/templates/vector_thead.html.erb', __FILE__)
+        end
+      ERB.new(File.read(table_thead_path).strip).result(binding)
+    end
+
+    def to_html_tbody(threshold=30)
+      table_tbody_path =
+        if index.is_a?(MultiIndex)
+          File.expand_path('../iruby/templates/vector_mi_tbody.html.erb', __FILE__)
+        else
+          File.expand_path('../iruby/templates/vector_tbody.html.erb', __FILE__)
+        end
+      ERB.new(File.read(table_tbody_path).strip).result(binding)
+    end
+
     def to_s
-      to_html
+      "#<#{self.class}#{': ' + @name.to_s if @name}(#{size})#{':category' if category?}>"
     end
 
-    # Create a summary of the Vector using Report Builder.
-    def summary(method=:to_text)
-      ReportBuilder.new(no_title: true).add(self).send(method)
+    # Create a summary of the Vector
+    # @param indent_level [Fixnum] indent level
+    # @return [String] String containing the summary of the Vector
+    # @example
+    #   dv = Daru::Vector.new [1, 2, 3]
+    #   puts dv.summary
+    #
+    #   # =
+    #   #   n :3
+    #   #   non-missing:3
+    #   #   median: 2
+    #   #   mean: 2.0000
+    #   #   std.dev.: 1.0000
+    #   #   std.err.: 0.5774
+    #   #   skew: 0.0000
+    #   #   kurtosis: -2.3333
+    def summary(indent_level=0)
+      non_missing = size - count_values(*Daru::MISSING_VALUES)
+      summary = '  =' * indent_level + "= #{name}" \
+                "\n  n :#{size}" \
+                "\n  non-missing:#{non_missing}"
+      case type
+      when :object
+        summary << object_summary
+      when :numeric
+        summary << numeric_summary
+      end
+      summary.split("\n").join("\n" + '  ' * indent_level)
     end
 
-    # :nocov:
-    def report_building b # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-      b.section(name: name) do |s|
-        s.text "n :#{size}"
-        s.text "n valid:#{count_values(*Daru::MISSING_VALUES)}"
-        if @type == :object
-          s.text  "factors: #{factors.to_a.join(',')}"
-          s.text  "mode: #{mode}"
-
-          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(count_values(*Daru::MISSING_VALUES))*100))]
-            end
-          end
-        end
+    # Displays summary for an object type Vector
+    # @return [String] String containing object vector summary
+    def object_summary
+      nval = count_values(*Daru::MISSING_VALUES)
+      summary = "\n  factors: #{factors.to_a.join(',')}" \
+                "\n  mode: #{mode.to_a.join(',')}" \
+                "\n  Distribution\n"
 
-        s.text "median: #{median}" if @type==:numeric || @type==:numeric
-        if @type==:numeric
-          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
-          end
-        end
+      data = frequencies.sort.each_with_index.map do |v, k|
+        [k, v, '%0.2f%%' % ((nval.zero? ? 1 : v.quo(nval))*100)]
       end
+
+      summary + Formatters::Table.format(data)
+    end
+
+    # Displays summary for an numeric type Vector
+    # @return [String] String containing numeric vector summary
+    def numeric_summary
+      summary = "\n  median: #{median}" +
+                "\n  mean: %0.4f" % mean
+      if sd
+        summary << "\n  std.dev.: %0.4f" % sd +
+                   "\n  std.err.: %0.4f" % se
+      end
+
+      if count_values(*Daru::MISSING_VALUES).zero?
+        summary << "\n  skew: %0.4f" % skew +
+                   "\n  kurtosis: %0.4f" % kurtosis
+      end
+      summary
     end
-    # :nocov:
 
     # Over rides original inspect for pretty printing in irb
     def inspect spacing=20, threshold=15
       row_headers = index.is_a?(MultiIndex) ? index.sparse_tuples : index.to_a
 
-      "#<#{self.class}(#{size})#{':cataegory' if category?}>\n" +
+      "#<#{self.class}(#{size})#{':category' if category?}>\n" +
         Formatters::Table.format(
           to_a.lazy.map { |v| [v] },
           headers: @name && [@name],
@@ -1095,14 +1278,30 @@ module Daru
       Daru::DataFrame.new ps
     end
 
+    # Returns an array of either none or integer values, indicating the
+    # +regexp+ matching with the given array.
+    #
+    # @param regexp [Regexp] A regular matching expression. For example, +/weeks/+.
+    #
+    # @return [Array] Containing either +nil+ or integer values, according to the match with the given +regexp+
+    #
+    # @example
+    #   dv = Daru::Vector.new(['3 days', '5 weeks', '2 weeks'])
+    #   dv.match(/weeks/)
+    #
+    #   # => [false, true, true]
+    def match(regexp)
+      @data.map { |value| !!(value =~ regexp) }
+    end
+
     # Creates a new vector consisting only of non-nil data
     #
     # == Arguments
     #
-    # @as_a [Symbol] Passing :array will return only the elements
+    # @param as_a [Symbol] Passing :array will return only the elements
     # as an Array. Otherwise will return a Daru::Vector.
     #
-    # @duplicate [Symbol] In case no missing data is found in the
+    # @param _duplicate [Symbol] In case no missing data is found in the
     # vector, setting this to false will return the same vector.
     # Otherwise, a duplicate will be returned irrespective of
     # presence of missing data.
@@ -1124,7 +1323,7 @@ module Daru
     deprecate :only_valid, :reject_values, 2016, 10
 
     # Return a vector with specified values removed
-    # @param [Array] *values values to reject from resultant vector
+    # @param values [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]
@@ -1146,7 +1345,7 @@ module Daru
     end
 
     # Return indexes of values specified
-    # @param [Array] *values values to find indexes for
+    # @param values [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
@@ -1336,6 +1535,17 @@ module Daru
 
     private
 
+    # Will lazily load the plotting library being used for this vector
+    def init_plotting_library
+      self.plotting_library = Daru.plotting_library
+    end
+
+    def copy(values)
+      # Make sure values is right-justified to the size of the vector
+      values.concat([nil] * (size-values.size)) if values.size < size
+      Daru::Vector.new(values[0...size], index: @index, name: @name)
+    end
+
     def nil_positions
       @nil_positions ||
         @nil_positions = size.times.select { |i| @data[i].nil? }
@@ -1348,6 +1558,11 @@ module Daru
         end
     end
 
+    # Helper method returning validity of arbitrary value
+    def valid_value?(v)
+      v.respond_to?(:nan?) && v.nan? || v.nil? ? false : true
+    end
+
     def initialize_vector source, opts
       index, source = parse_source(source, opts)
       set_name opts[:name]
@@ -1358,8 +1573,6 @@ module Daru
       guard_sizes!
 
       @possibly_changed_type = true
-      # Include plotting functionality
-      self.plotting_library = Daru.plotting_library
     end
 
     def parse_source source, opts
@@ -1413,7 +1626,7 @@ module Daru
     end
 
     # Note: To maintain sanity, this _MUST_ be the _ONLY_ place in daru where the
-    # @dtype variable is set and the underlying data type of vector changed.
+    # @param dtype [db_type] variable is set and the underlying data type of vector changed.
     def cast_vector_to dtype, source=nil, nm_dtype=nil
       source = @data.to_a if source.nil?
 
@@ -1426,7 +1639,7 @@ module Daru
         else raise ArgumentError, "Unknown dtype #{dtype}"
         end
 
-      @dtype = dtype || :array
+      @dtype = dtype
       new_vector
     end
 
@@ -1442,7 +1655,6 @@ module Daru
 
     # Raises IndexError when one of the positions is an invalid position
     def validate_positions *positions
-      positions = [positions] if positions.is_a? Integer
       positions.each do |pos|
         raise IndexError, "#{pos} is not a valid position." if pos >= size
       end