daru 0.0.5 → 0.1.0

data/lib/daru/monkeys.rb

@@ -1,5 +1,41 @@
 class Array
-  def daru_vector name=nil, index=nil, dtype=Array
+  # Recode repeated values on an array, adding the number of repetition
+  # at the end
+  # Example:
+  #   a=%w{a b c c d d d e}
+  #   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
+
+      collect do |f|
+        if repeated.include? f
+          ns[f] += 1
+          sprintf('%s_%d', f, ns[f])
+        else
+          f
+        end
+      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
 
@@ -11,8 +47,8 @@ class Array
 end
 
 class Range
-  def daru_vector name=nil, index=nil, dtype=Array
-    Daru::Vector.new self, name: name, index: index, dtype: Array
+  def daru_vector name=nil, index=nil, dtype=:array
+    Daru::Vector.new self, name: name, index: index, dtype: dtype
   end
 
   alias_method :dv, :daru_vector
@@ -23,8 +59,8 @@ class Range
 end
 
 class Hash
-  def daru_vector index=nil, dtype=Array
-    Daru::Vector.new self.values[0], name: self.keys[0], index: index, dtype: Array
+  def daru_vector index=nil, dtype=:array
+    Daru::Vector.new self.values[0], name: self.keys[0], index: index, dtype: dtype
   end
 
   alias_method :dv, :daru_vector
@@ -32,7 +68,7 @@ end
 
 class NMatrix
   def daru_vector name=nil, index=nil, dtype=NMatrix
-    Daru::Vector.new self, name: name, index: index, dtype: NMatrix
+    Daru::Vector.new self, name: name, index: index, dtype: :nmatrix
   end
 
   alias_method :dv, :daru_vector
@@ -40,7 +76,7 @@ end
 
 class MDArray
   def daru_vector name=nil, index=nil, dtype=MDArray
-    Daru::Vector.new self, name: name, index: index, dtype: MDArray
+    Daru::Vector.new self, name: name, index: index, dtype: :mdarray
   end
 
   alias_method :dv, :daru_vector
@@ -58,4 +94,14 @@ class Matrix
       e / other.to_a.flatten[index]
     end
   end
+end
+
+class String
+  def is_number?
+    if self =~ /^-?\d+[,.]?\d*(e-?\d+)?$/
+      true
+    else
+      false
+    end
+  end
 end

data/lib/daru/multi_index.rb

@@ -17,12 +17,12 @@ module Daru
     attr_reader :values
     
     # Initialize a MultiIndex by passing a tuple of indexes. The order assigned
-    #   to the multi index corresponds to the position of the tuple in the array
-    #   of tuples.
+    # to the multi index corresponds to the position of the tuple in the array
+    # of tuples.
     # 
     # Although you can create your own hierarchially indexed Vectors and DataFrames,
-    #   this class currently contains minimal error checking and is mainly used 
-    #   internally for summarizing, splitting and grouping of data.
+    # this class currently contains minimal error checking and is mainly used 
+    # internally for summarizing, splitting and grouping of data.
     # 
     # == Arguments
     # 
@@ -68,6 +68,19 @@ module Daru
       end
     end
 
+    def + other
+      other.flatten!
+      tuples = to_a
+      raise ArgumentError, "Incomplete tuple #{other}" unless 
+        tuples.all? { |t| t.size == other.size }
+
+      Daru::MultiIndex.new(tuples << (other))
+    end
+
+    def empty?
+      @relation_hash.empty?
+    end
+
     # Compare two MultiIndex objects for equality based on the contents of their
     # relation hashes. Does not take object_id into account.
     def == other
@@ -108,6 +121,10 @@ module Daru
       tuple.empty? ? nil : tuple
     end
 
+    def size
+      to_a.size
+    end
+
    private
 
     # Deep compare two hashes

data/lib/daru/plotting/dataframe.rb

@@ -1,9 +1,3 @@
-begin
-  require 'nyaplot'
-rescue LoadError => e
-  puts "#{e}"
-end
-
 module Daru
   module Plotting
     module DataFrame
@@ -12,36 +6,100 @@ module Daru
       # 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 
+      # notebooks whose links you can find in the README.
+      # 
       # == Options
-      #   +:type+  - Type of plot (scatter, bar, histogram)
-      #   +:legends+ - The names of the vectors that are to be used as X and Y axes.
-      #   The vectors names must be specified as symbols inside an Array. They 
-      #   also should be specified in the right order. For example, passing [:a, :b]
-      #   will keep vector :a as the X axis and :b as the Y axis. Passing [:a]
-      #   keep :a as the X axis and plot the frequency with which :a appears 
-      #   on the Y axis.
-      #   +:frame+ - Pass this as *true* to disable plotting the graph directly
-      #   and instead manually create Nyaplot::Frame object inside the block using
-      #   the Nyaplot::Plot object for plotting one or many graphs in a frame.
+      # 
+      # * +: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
-      #   df = Daru::DataFrame.new({a:[0,1,2,3,4], b:[10,20,30,40,50]})
-      #   df.plot legends: [:a, :b], type: :bar
+      #   # Simple bar chart
+      #   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={}
         options = {
-          type:  :scatter,
-          frame: false,
-          legends: []
+          type:  :scatter
         }.merge(opts)
 
         plot = Nyaplot::Plot.new
-        diagram = plot.add_with_df(Nyaplot::DataFrame.new(self.to_a[0]), 
-          options[:type], *options[:legends])
+        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
+          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 unless options[:frame]
+        plot.show
       end
+
+     private
+
+      def single_diagram? options
+        options[:x] and options[:x].is_a?(Symbol)
+      end
+
+      def add_single_diagram plot, options
+        args = [
+          self.to_nyaplotdf, 
+          options[:type], 
+          options[:x]
+        ]
+
+        args << options[:y] if(options[:y])
+
+        plot.add_with_df(*args)
+      end
+
+      def add_multiple_diagrams plot, options
+        types  = extract_option :type, options
+        x_vecs = extract_option :x, options
+        y_vecs = extract_option :y, options
+
+        diagrams   = []
+        nyaplot_df = self.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,
+            types[i],
+            x_vecs[i],
+            y_vecs[i]
+          )
+        end
+
+        diagrams
+      end
+
+      def extract_option opt, options
+        if options[opt]
+          o = options[opt]
+          o.is_a?(Array) ? o : [o]
+        else
+          arr = options.keys
+          arr.keep_if { |a| a =~ Regexp.new("\\A#{opt.to_s}") }.sort
+          arr.map { |a| options[a] }
+        end
+      end
+
     end
   end
-end
+end if Daru.has_nyaplot?

data/lib/daru/plotting/vector.rb

@@ -1,9 +1,3 @@
-begin
-  require 'nyaplot'
-rescue LoadError => e
-  puts "#{e}"
-end
-
 module Daru
   module Plotting
     module Vector
@@ -27,9 +21,14 @@ module Daru
           type: :scatter
         }.merge(opts)
 
-        x_axis = options[:type] == :scatter ? Array.new(@size) { |i| i } : @index.to_a
-        plot   = Nyaplot::Plot.new
-        diagram = plot.add( options[:type], x_axis, @data.to_a )
+        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
 
         yield plot, diagram if block_given?
         
@@ -37,4 +36,4 @@ module Daru
       end
     end
   end
-end
+end if Daru.has_nyaplot?

data/lib/daru/vector.rb

@@ -5,13 +5,14 @@ require 'maths/statistics/vector.rb'
 require 'plotting/vector.rb'
 require 'accessors/array_wrapper.rb'
 require 'accessors/nmatrix_wrapper.rb'
+require 'accessors/gsl_wrapper.rb'
 
 module Daru
   class Vector
     include Enumerable
     include Daru::Maths::Arithmetic::Vector
     include Daru::Maths::Statistics::Vector
-    include Daru::Plotting::Vector
+    include Daru::Plotting::Vector if Daru.has_nyaplot?
 
     def each(&block)
       return to_enum(:each) unless block_given?
@@ -20,37 +21,55 @@ module Daru
       self
     end
 
-    def map!(&block)
-      return to_enum(:map!) unless block_given?
+    def each_index(&block)
+      return to_enum(:each_index) unless block_given?
 
-      @data.map!(&block)
+      @index.each(&block)
       self
     end
 
-    def map(&block)
-      return to_enum(:map) unless block_given?
+    def each_with_index(&block)
+      return to_enum(:each_with_index) unless block_given?
 
-      Daru::Vector.new @data.map(&block), name: @name, index: @index, dtype: @dtype
+      @index.each { |i|  yield(self[i], i) }
+      self
     end
 
-    alias_method :recode, :map
+    def map!(&block)
+      return to_enum(:map!) unless block_given?
+      @data.map!(&block)
+      update
+      self
+    end
 
+    # The name of the Daru::Vector. String.
     attr_reader :name
+    # The row index. Can be either Daru::Index or Daru::MultiIndex.
     attr_reader :index
+    # The total number of elements of the vector.
     attr_reader :size
+    # The underlying dtype of the Vector. Can be either :array, :nmatrix or :gsl.
     attr_reader :dtype
+    # If the dtype is :nmatrix, this attribute represents the data type of the
+    # underlying NMatrix object. See NMatrix docs for more details on NMatrix
+    # data types.
     attr_reader :nm_dtype
-    attr_reader :nil_positions
+    # An Array or the positions in the vector that are being treated as 'missing'.
+    attr_reader :missing_positions
+    # Store a hash of labels for values. Supplementary only. Recommend using index
+    # for proper usage.
+    attr_accessor :labels
 
     # Create a Vector object.
+    # 
     # == Arguments
     # 
-    # @param source[Array,Hash] - Supply elements in the form of an Array or a Hash. If Array, a
-    #   numeric index will be created if not supplied in the options. Specifying more
-    #   index elements than actual values in *source* will insert *nil* into the 
-    #   surplus index elements. When a Hash is specified, the keys of the Hash are 
-    #   taken as the index elements and the corresponding values as the values that
-    #   populate the vector.
+    # @param source[Array,Hash] - Supply elements in the form of an Array or a 
+    # Hash. If Array, a numeric index will be created if not supplied in the 
+    # options. Specifying more index elements than actual values in *source* 
+    # will insert *nil* into the surplus index elements. When a Hash is specified, 
+    # the keys of the Hash are taken as the index elements and the corresponding 
+    # values as the values that populate the vector.
     # 
     # == Options
     # 
@@ -58,10 +77,14 @@ module Daru
     # 
     # * +:index+ - Index of the vector
     # 
-    # * +:dtype+ - The underlying data type. Can be :array or :nmatrix. Default :array.
+    # * +:dtype+ - The underlying data type. Can be :array, :nmatrix or :gsl. 
+    # Default :array.
     # 
     # * +:nm_dtype+ - For NMatrix, the data type of the numbers. See the NMatrix docs for
-    #     further information on supported data type.
+    # further information on supported data type.
+    # 
+    # * +:missing_values+ - An Array of the values that are to be treated as 'missing'.
+    # nil is the default missing value.
     # 
     # == Usage
     # 
@@ -79,7 +102,7 @@ module Daru
       name   = opts[:name]
       set_name name
 
-      @data  = cast_vector_to(opts[:dtype], source, opts[:nm_dtype])
+      @data  = cast_vector_to(opts[:dtype] || :array, source, opts[:nm_dtype])
       @index = create_index(index || @data.size)
       
       if @index.size > @data.size
@@ -90,10 +113,81 @@ module Daru
       end
 
       @possibly_changed_type = true
-      set_nil_positions
+      set_missing_values opts[:missing_values]
+      set_missing_positions
       set_size
     end
 
+    # Create a new vector by specifying the size and an optional value
+    # and block to generate values.
+    # 
+    # == Description
+    #
+    # The *new_with_size* class method lets you create a Daru::Vector
+    # by specifying the size as the argument. The optional block, if 
+    # supplied, is run once for populating each element in the Vector.
+    #
+    # The result of each run of the block is the value that is ultimately
+    # assigned to that position in the Vector.
+    #
+    # == Options
+    # :value
+    # All the rest like .new
+    def self.new_with_size n, opts={}, &block
+      value = opts[:value]
+      opts.delete :value
+      if block
+        vector = Daru::Vector.new n.times.map { |i| block.call(i) }, opts
+      else
+        vector = Daru::Vector.new n.times.map { value }, opts
+      end
+      vector
+    end
+
+    # Create a vector using (almost) any object
+    # * Array: flattened
+    # * Range: transformed using to_a
+    # * Daru::Vector
+    # * Numeric and string values
+    # 
+    # == Description
+    #
+    # The `Vector.[]` class method creates a vector from almost any
+    # object that has a `#to_a` method defined on it. It is similar
+    # to R's `c` method.
+    # 
+    # == Usage
+    # 
+    #   a = Daru::Vector[1,2,3,4,6..10]
+    #   #=>
+    #   # <Daru::Vector:99448510 @name = nil @size = 9 >
+    #   #   nil
+    #   # 0   1
+    #   # 1   2
+    #   # 2   3
+    #   # 3   4
+    #   # 4   6
+    #   # 5   7
+    #   # 6   8
+    #   # 7   9
+    #   # 8  10
+    def self.[](*args)
+      values = []
+      args.each do |a|
+        case a
+        when Array
+          values.concat a.flatten
+        when Daru::Vector
+          values.concat a.to_a
+        when Range
+          values.concat  a.to_a
+        else
+          values << a
+        end
+      end
+      Daru::Vector.new(values)
+    end
+
     # Get one or more elements with specified index or a range.
     # 
     # == Usage
@@ -106,6 +200,7 @@ module Daru
     #   # For vectors employing hierarchial multi index
     #   
     def [](*indexes)
+      indexes.map! { |e| e.respond_to?(:to_sym) ? e.to_sym : e }
       location = indexes[0]
       if @index.is_a?(MultiIndex)
         result = 
@@ -158,6 +253,19 @@ module Daru
       end
     end
 
+    # Just like in Hashes, you can specify the index label of the Daru::Vector
+    # and assign an element an that place in the Daru::Vector.
+    # 
+    # == Usage
+    # 
+    #   v = Daru::Vector.new([1,2,3], index: [:a, :b, :c])
+    #   v[:a] = 999
+    #   #=> 
+    #   ##<Daru::Vector:90257920 @name = nil @size = 3 >
+    #   #    nil
+    #   #  a 999
+    #   #  b   2
+    #   #  c   3
     def []=(*location, value)
       cast(dtype: :array) if value.nil? and dtype != :array
 
@@ -182,7 +290,38 @@ module Daru
       end
 
       set_size
-      set_nil_positions
+      set_missing_positions unless Daru.lazy_update
+    end
+
+    # The values to be treated as 'missing'. *nil* is the default missing
+    # type. To set missing values see the missing_values= method.
+    def missing_values
+      @missing_values.keys  
+    end
+
+    # Assign an Array to treat certain values as 'missing'.
+    # 
+    # == Usage
+    # 
+    #   v = Daru::Vector.new [1,2,3,4,5]
+    #   v.missing_values = [3]
+    #   v.update
+    #   v.missing_positions 
+    #   #=> [2]
+    def missing_values= values
+      set_missing_values values
+      set_missing_positions unless Daru.lazy_update
+    end
+
+    # Method for updating the metadata (i.e. missing value positions) of the
+    # after assingment/deletion etc. are complete. This is provided so that
+    # time is not wasted in creating the metadata for the vector each time
+    # 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
     end
 
     # Two vectors are equal if the have the exact same index values corresponding
@@ -199,21 +338,20 @@ module Daru
       end
     end
 
-    def << element
-      concat element
+    def head q=10
+      self[0..(q-1)]
     end
 
-    def push element
-      concat element  
+    def tail q=10
+      self[(@size - q - 1)..(@size-1)]
     end
 
-    def head q=10
-      self[0..q]
+    # Reports whether missing data is present in the Vector.
+    def has_missing_data?
+      !missing_positions.empty?
     end
+    alias :flawed? :has_missing_data?
 
-    def tail q=10
-      self[-q..-1]
-    end
 
     # Append an element to the vector by specifying the element and index
     def concat element, index=nil
@@ -231,8 +369,10 @@ module Daru
       end
       @data[@index[index]] = element
       set_size
-      set_nil_positions
+      set_missing_positions unless Daru.lazy_update
     end
+    alias :push :concat 
+    alias :<< :concat
 
     # Cast a vector to a new data type.
     # 
@@ -240,11 +380,11 @@ module Daru
     # 
     # * +:dtype+ - :array for Ruby Array. :nmatrix for NMatrix.
     def cast opts={}
-      dtype = opts[:dtype]
+      dt = opts[:dtype]
       raise ArgumentError, "Unsupported dtype #{opts[:dtype]}" unless 
-        dtype == :array or dtype == :nmatrix
+        dt == :array or dt == :nmatrix or dt == :gsl
 
-      @data = cast_vector_to dtype
+      @data = cast_vector_to dt unless @dtype == dt
     end
 
     # Delete an element by value
@@ -264,7 +404,7 @@ module Daru
       end
 
       set_size
-      set_nil_positions
+      set_missing_positions unless Daru.lazy_update
     end
 
     # The type of data contained in the vector. Can be :object or :numeric. If
@@ -308,11 +448,19 @@ module Daru
       Daru::Vector.new uniq_vector, name: @name, index: new_index, dtype: @dtype
     end
 
+    def any? &block
+      @data.data.any?(&block)
+    end
+
+    def all? &block
+      @data.data.all?(&block)
+    end
+
     # Sorts a vector according to its values. If a block is specified, the contents
-    #   will be evaluated and data will be swapped whenever the block evaluates 
-    #   to *true*. Defaults to ascending order sorting. Any missing values will be
-    #   put at the end of the vector. Preserves indexing. Default sort algorithm is
-    #   quick sort.
+    # will be evaluated and data will be swapped whenever the block evaluates 
+    # to *true*. Defaults to ascending order sorting. Any missing values will be
+    # put at the end of the vector. Preserves indexing. Default sort algorithm is
+    # quick sort.
     # 
     # == Options
     # 
@@ -323,7 +471,7 @@ module Daru
     # 
     #   v = Daru::Vector.new ["My first guitar", "jazz", "guitar"]
     #   # Say you want to sort these strings by length.
-    #   v.sort { |a,b| a.length <=> b.length }
+    #   v.sort(ascending: false) { |a,b| a.length <=> b.length }
     def sort opts={}, &block
       opts = {
         ascending: true,
@@ -339,18 +487,138 @@ module Daru
       Daru::Vector.new(vector, index: create_index(index), name: @name, dtype: @dtype)
     end
 
-    # Just sort the data and get an Array in return using Enumerable#sort. Non-destructive.
+    # Just sort the data and get an Array in return using Enumerable#sort. 
+    # Non-destructive.
     def sorted_data &block
       @data.to_a.sort(&block)
     end
 
-    # Returns *true* if the value passed actually exists in the vector.
+    # Returns *true* if the value passed is actually exists or is not marked as
+    # a *missing value*.
     def exists? value
-      !self[index_of(value)].nil?
+      !@missing_values.has_key?(self[index_of(value)])
+    end
+
+    # Like map, but returns a Daru::Vector with the returned values.
+    def recode dt=nil, &block
+      return to_enum(:recode) unless block_given?
+
+      dup.recode! dt, &block
+    end
+
+    # Destructive version of recode!
+    def recode! dt=nil, &block
+      return to_enum(:recode!) unless block_given?
+
+      @data.map!(&block).data
+      @data = cast_vector_to(dt || @dtype)
+      self
+    end
+
+    def delete_if &block
+      return to_enum(:delete_if) unless block_given?
+
+      keep_e = []
+      keep_i = []
+      each_with_index do |n, i|
+        if yield(n)
+          keep_e << n
+          keep_i << i
+        end
+      end
+
+      @data = cast_vector_to @dtype, keep_e
+      @index = @index.is_a?(MultiIndex) ? MultiIndex.new(keep_i) : Index.new(keep_i)
+      set_missing_positions unless Daru.lazy_update
+      set_size
+
+      self
+    end
+
+    # 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
+      h = {}
+      (0...size).each do |i|
+        if !(yield @data[i])
+          h[i] = @data[i]
+        end
+      end
+
+      h
+    end
+
+    # Return an Array with the data splitted by a separator.
+    #   a=Daru::Vector.new(["a,b","c,d","a,b","d"])
+    #   a.splitted
+    #     =>
+    #   [["a","b"],["c","d"],["a","b"],["d"]]
+    def splitted sep=","
+      @data.map do |s|
+        if s.nil?
+          nil
+        elsif s.respond_to? :split
+          s.split sep
+        else
+          [s]
+        end
+      end
+    end
+
+    # Returns a hash of Vectors, defined by the different values
+    # defined on the fields
+    # Example:
+    #
+    #  a=Daru::Vector.new(["a,b","c,d","a,b"])
+    #  a.split_by_separator
+    #  =>  {"a"=>#<Daru::Vector:0x7f2dbcc09d88
+    #        @data=[1, 0, 1]>,
+    #       "b"=>#<Daru::Vector:0x7f2dbcc09c48
+    #        @data=[1, 1, 0]>,
+    #      "c"=>#<Daru::Vector:0x7f2dbcc09b08
+    #        @data=[0, 1, 1]>}
+    #
+    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
+
+      split_data.each do |r|
+        if r.nil?
+          factors.each do |f|
+            out[f].push(nil)
+          end
+        else
+          factors.each do |f|
+            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
+    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
+    end
+
+    def reset_index!
+      @index = Daru::Index.new(Array.new(size) { |i| i })
+      self
     end
 
     # Returns a vector which has *true* in the position where the element in self
-    #   is nil, and false otherwise.
+    # is nil, and false otherwise.
     # 
     # == Usage
     # 
@@ -383,26 +651,34 @@ module Daru
     end
 
     # Replace all nils in the vector with the value passed as an argument. Destructive.
-    #   See #replace_nils for non-destructive version
+    # See #replace_nils for non-destructive version
     # 
     # == Arguments
     # 
     # * +replacement+ - The value which should replace all nils
     def replace_nils! replacement
-      nil_positions.each do |idx|
+      missing_positions.each do |idx|
         self[idx] = replacement
       end
 
       self
     end
 
+    def detach_index
+      Daru::DataFrame.new({
+        index: @index.to_a.map(&:to_s),
+        vector: @data.to_a
+      })
+    end
+
     # Non-destructive version of #replace_nils!
     def replace_nils replacement
       self.dup.replace_nils!(replacement)
     end
 
+    # number of non-missing elements
     def n_valid
-      @size
+      @size - missing_positions.size
     end
 
     # Returns *true* if an index exists
@@ -425,6 +701,20 @@ module Daru
       end
     end
 
+    # 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
+    end
+
     # Convert to hash. Hash keys are indexes and values are the correspoding elements
     def to_hash
       @index.inject({}) do |hsh, index|
@@ -446,12 +736,24 @@ module Daru
     # Convert to html for iruby
     def to_html threshold=30
       name = @name || 'nil'
-      html = '<table>' + '<tr><th> </th><th>' + name.to_s + '</th></tr>'
+      html = "<table>" + 
+        "<tr>" +
+          "<th colspan=\"2\">" + 
+            "Daru::Vector:#{self.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>'
+
+          last_index = @index.to_a.last
+          html += '<tr>' + 
+                    '<td>' + last_index.to_s       + '</td>' +
+                    '<td>' + self[last_index].to_s + '</td>' +
+                  '</tr>'
           break
         end
       end
@@ -464,11 +766,45 @@ module Daru
       to_html
     end
 
+    # Create a summary of the Vector using Report Builder.
+    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|
+        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|
+              key = @index.include?(k) ? @index[k] : k
+              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)
+        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
+      end
+    end
+
     # 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, 
-                 @data    .map(&:to_s).map(&:size).max,
+                 (@index.to_a.map(&:to_s).map(&:size).max || 0), 
+                 (@data    .map(&:to_s).map(&:size).max || 0),
                  'nil'.size].max
 
       content   = ""
@@ -503,6 +839,11 @@ module Daru
     # 
     # @param new_name [Symbol] The new name.
     def rename new_name
+      if new_name.is_a?(Numeric)
+        @name = new_name 
+        return
+      end
+      
       @name = new_name.to_sym
     end
 
@@ -511,12 +852,176 @@ module Daru
       Daru::Vector.new @data.dup, name: @name, index: @index.dup
     end
 
+    # == Bootstrap
+    # Generate +nr+ resamples (with replacement) of size  +s+
+    # from vector, computing each estimate from +estimators+
+    # over each resample.
+    # +estimators+ could be
+    # a) Hash with variable names as keys and lambdas as  values
+    #   a.bootstrap(:log_s2=>lambda {|v| Math.log(v.variance)},1000)
+    # b) Array with names of method to bootstrap
+    #   a.bootstrap([:mean, :sd],1000)
+    # c) A single method to bootstrap
+    #   a.jacknife(:mean, 1000)
+    # If s is nil, is set to vector size by default.
+    #
+    # Returns a DataFrame where each vector is a vector
+    # of length +nr+ containing the computed resample estimates.
+    def bootstrap(estimators, nr, s=nil)
+      s ||= size
+      h_est, es, bss = prepare_bootstrap(estimators)
+
+      nr.times do |i|
+        bs = sample_with_replacement(s)
+        es.each do |estimator|
+          bss[estimator].push(h_est[estimator].call(bs))
+        end
+      end
+
+      es.each do |est|
+        bss[est] = Daru::Vector.new bss[est]
+      end
+
+      Daru::DataFrame.new bss
+    end
+
+    # == Jacknife
+    # Returns a dataset with jacknife delete-+k+ +estimators+
+    # +estimators+ could be:
+    # a) Hash with variable names as keys and lambdas as values
+    #   a.jacknife(:log_s2=>lambda {|v| Math.log(v.variance)})
+    # b) Array with method names to jacknife
+    #   a.jacknife([:mean, :sd])
+    # c) A single method to jacknife
+    #   a.jacknife(:mean)
+    # +k+ represent the block size for block jacknife. By default
+    # is set to 1, for classic delete-one jacknife.
+    #
+    # Returns a dataset where each vector is an vector
+    # of length +cases+/+k+ containing the computed jacknife estimates.
+    #
+    # == Reference:
+    # * Sawyer, S. (2005). Resampling Data: Using a Statistical Jacknife.
+    def jackknife(estimators, k=1)
+      raise "n should be divisible by k:#{k}" unless size % k==0
+
+      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
+
+      nb.times do |i|
+        other = @data.dup
+        other.slice!(i*k, k)
+        other = Daru::Vector.new other
+
+        es.each do |estimator|
+          # Add pseudovalue
+          ps[estimator].push(
+            nb * est_n[estimator] - (nb-1) * h_est[estimator].call(other))
+        end
+      end
+
+      es.each do |est|
+        ps[est] = Daru::Vector.new ps[est]
+      end
+      Daru::DataFrame.new ps
+    end
+
+    # Creates a new vector consisting only of non-nil data
+    # 
+    # == Arguments
+    # 
+    # @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
+    # vector, setting this to false will return the same vector.
+    # 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
+
+      new_index = @index.to_a - missing_positions
+      new_vector = new_index.map do |idx|
+        self[idx]
+      end
+
+      return new_vector if as_a != :vector
+      
+      Daru::Vector.new new_vector, index: new_index, name: @name, dtype: dtype
+    end
+
+    # Returns a Vector containing only missing data (preserves indexes).
+    def only_missing as_a=:vector
+      if as_a == :vector
+        self[*missing_positions]
+      elsif as_a == :array
+        self[*missing_positions].to_a
+      end
+    end
+
+    # Returns a Vector with only numerical data. Missing data is included
+    # but non-Numeric objects are excluded. Preserves index.
+    def only_numerics
+      numeric_indexes = []
+
+      each_with_index do |v, i|
+        numeric_indexes << i if(v.kind_of?(Numeric) or @missing_values.has_key?(v))
+      end
+
+      self[*numeric_indexes]
+    end
+
+    # Returns the database type for the vector, according to its content
+    def db_type(dbs=:mysql)
+      # 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"
+      else
+        return "INTEGER"
+      end
+    end
+
     # Copies the structure of the vector (i.e the index, size, etc.) and fills all
-    #   all values with nils.
+    # all values with nils.
     def clone_structure
       Daru::Vector.new(([nil]*@size), name: @name, index: @index.dup)
     end
 
+    # Save the vector to a file
+    # 
+    # == Arguments
+    # 
+    # * filename - Path of file where the vector is to be saved
+    def save filename
+      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})
+    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])
+    end
+
     def daru_vector *name
       self
     end
@@ -535,6 +1040,26 @@ module Daru
 
    private
 
+    # For an array or hash of estimators methods, returns
+    # an array with three elements
+    # 1.- A hash with estimators names as keys and lambdas as values
+    # 2.- An array with estimators names
+    # 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)
+
+      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
+      end
+      bss = h_est.keys.inject({}) { |h,v| h[v] = []; 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]
@@ -599,18 +1124,17 @@ 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.
+    # @dtype variable is set and the underlying data type of vector changed.
     def cast_vector_to dtype, source=nil, nm_dtype=nil
-      source = @data if source.nil?
-      return @data if @dtype and @dtype == dtype
+      source = @data.to_a if source.nil?
 
       new_vector = 
       case dtype
-      when :array   then Daru::Accessors::ArrayWrapper.new(source.to_a.dup, self)
-      when :nmatrix then Daru::Accessors::NMatrixWrapper.new(source.to_a.dup, 
-        self, nm_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 Daru::Accessors::ArrayWrapper.new(source.dup, self)
+      else raise "Unknown dtype #{dtype}"
       end
 
       @dtype = dtype || :array
@@ -649,12 +1173,11 @@ module Daru
       end
     end
 
-    def set_nil_positions
-      @nil_positions = []
+    def set_missing_positions
+      @missing_positions = []
       @index.each do |e|
-        @nil_positions << e if(self[e].nil?)
+        @missing_positions << e if (@missing_values.has_key?(self[e]))
       end
-      @nil_positions.uniq!
     end
 
     def create_index potential_index
@@ -669,5 +1192,17 @@ module Daru
       pos = index_for location
       pos ? @data[pos] : nil
     end
+
+    # Setup missing_values. The missing_values instance variable is set
+    # as a Hash for faster lookup times.
+    def set_missing_values values_arry
+      @missing_values = {}
+      @missing_values[nil] = 0
+      if values_arry
+        values_arry.each do |e|
+          @missing_values[e] = 0
+        end
+      end
+    end
   end
 end