daru 0.0.4 → 0.0.5

data/lib/daru/monkeys.rb

@@ -50,4 +50,12 @@ class Numeric
   def square
     self * self
   end
+end
+
+class Matrix
+  def elementwise_division other
+    self.map.with_index do |e, index|
+      e / other.to_a.flatten[index]
+    end
+  end
 end

data/lib/daru/multi_index.rb

@@ -0,0 +1,199 @@
+module Daru
+  # Class for holding multi index on Vector and DataFrame.
+  class MultiIndex
+    include Enumerable
+
+    def each(&block)
+      to_a.each(&block)
+      self
+    end
+
+    def map(&block)
+      to_a.map(&block)
+    end
+
+    attr_reader :relation_hash
+    attr_reader :size
+    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.
+    # 
+    # 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.
+    # 
+    # == Arguments
+    # 
+    # * +source+ - The array of arrays from which the multi index is to be created.
+    # 
+    # == Usage
+    # 
+    #   tuples = [:a,:a,:b,:b].zip([:one,:two,:one,:two])
+    #   #=> [[:a, :one], [:a, :two], [:b, :one], [:b, :two]]
+    #   Daru::MultiIndex.new(tuples)
+    def initialize source, values=nil
+      @relation_hash = {}
+      @size = source.size
+      values = Array.new(source.size) { |i| i } if values.nil?
+      create_relation_hash source, values
+      @relation_hash.freeze
+      @values = values
+    end
+
+    def [] *indexes
+      indexes.flatten!
+      location = indexes[0]
+
+      if location.is_a?(Symbol)
+        result = read_relation_hash @relation_hash, indexes, 0
+        return nil if result.nil?
+        result.is_a?(Integer) ? result : Daru::MultiIndex.new(*make_tuples(result))
+      else
+        case location
+        when Integer
+          self[@relation_hash.keys[location]]
+        when Range
+          first = location.first
+          last  = location.last
+
+          hsh = {}
+          first.upto(last) do |index|
+            key = @relation_hash.keys[index]
+            hsh[key] = read_relation_hash(@relation_hash, [key], 0)
+          end
+          Daru::MultiIndex.new(*make_tuples(hsh))
+        end
+      end
+    end
+
+    # Compare two MultiIndex objects for equality based on the contents of their
+    # relation hashes. Does not take object_id into account.
+    def == other
+      return false if size != other.size
+      deep_compare @relation_hash, other.relation_hash
+    end
+
+    # Convert a MultiIndex back to tuples (array of arrays). Will retain the 
+    # order of creation.
+    def to_a
+      make_tuples(@relation_hash)[0]
+    end
+
+    # Completely duplicate a MultiIndex object and its contents.
+    def dup
+      Daru::MultiIndex.new to_a
+    end
+    
+    # Check whether a tuple or identifier number exists in the multi index. 
+    # The argument *tuple* can either a complete or incomplete tuple, or a number.
+    def include? tuple
+      tuple = [tuple] unless tuple.is_a?(Array)
+      tuple.flatten!
+      !!read_relation_hash(@relation_hash, tuple, 0)
+    end
+
+    # Obtain the tuple that correponds with the indentifier number.
+    # 
+    # == Arguments
+    # 
+    # * +key+ - A number for which the tuple is to be obtained.
+    # 
+    # == Usage
+    #   
+    #   mi.key(3) #=> [:a,:two,:baz]
+    def key key
+      tuple = find_tuple_for(@relation_hash, key)
+      tuple.empty? ? nil : tuple
+    end
+
+   private
+
+    # Deep compare two hashes
+    def deep_compare this, other
+      if this == other
+        return true if this.is_a?(Integer) and other.is_a?(Integer)
+        this.each_key do |key|
+          deep_compare this[key], other[key]
+        end
+      else
+        return false
+      end
+      true
+    end
+
+    # Create tuples out of the relation hash based on the order of the identifier
+    # numbers. Returns an array of arrays containing the tuples and another
+    # containing their corresponding index numbers.
+    def make_tuples relation_hash
+      tuples = []
+      new_vals = []
+      values.each do |number|
+        tuple = find_tuple_for(relation_hash, number)
+        unless tuple.empty?
+          tuples << tuple
+          new_vals << number
+        end
+      end
+      [tuples,new_vals]
+    end
+
+    # Finds and returns a single tuple for a particular identifier number
+    def find_tuple_for relation_hash, number
+      tuple = []
+      search_for_number number, relation_hash, tuple
+      tuple.reverse
+    end
+
+    # Search for a number and store its corresponding tuple in *tuple*. Returns 
+    # true if the number is successfully found.
+    def search_for_number number, relation_hash, tuple
+      found = false
+      relation_hash.each_key do |key|
+        value = relation_hash[key]
+        if value.is_a?(Hash)
+          if search_for_number(number, value, tuple)
+            tuple << key
+            found = true
+          end
+        elsif value == number
+          tuple << key
+          found = true
+        end
+      end
+
+      found
+    end
+
+    # Read the relation hash and return a sub-relation hash or the number to which
+    #   indexes belogs to.
+    def read_relation_hash relation_hash, indexes, index
+      identifier = indexes[index]
+      value      = relation_hash[identifier]
+
+      indexes[index+1].nil? ? value : read_relation_hash(value,indexes,index+1)
+    end
+
+    # Create the relation hash from supplied tuples.
+    def create_relation_hash source, values
+      source.each_with_index do |tuple, idx|
+        populate @relation_hash, tuple, 0, values[idx]
+      end   
+    end
+
+    def populate relation_hash, tuple, index, number
+      identifier = tuple[index]
+
+      if identifier
+        if tuple[index+1] 
+          relation_hash[identifier] ||= {}
+        else
+          relation_hash[identifier] = number
+          return
+        end
+        populate relation_hash[identifier], tuple, index+1, number
+      end
+    end
+  end
+end

data/lib/daru/plotting/dataframe.rb

@@ -7,40 +7,40 @@ end
 module Daru
   module Plotting
     module DataFrame
-      # Plots a DataFrame with Nyaplot on IRuby using the given options.
-      # == Arguments
-      #   +x+ - Vector name to be used for x-axis
-      #   +y+ - Vector name to be used for y-axis
+      # 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.
+      # 
       # == Options
-      #   type    - Type of plot (scatter, bar, histogram)
-      #   title   - Title of plot
-      #   x_label - X - label
-      #   y_label - Y - label
-      #   tooltip_contents - Contents of the tooltip. Array of vector names
-      #   fill_by - Vector name by which each plotted element is colored 
-      #   shape_by- Vector name by which dots in a scatter plot are shaped
+      #   +: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.
+      # 
       # == Usage
       #   df = Daru::DataFrame.new({a:[0,1,2,3,4], b:[10,20,30,40,50]})
-      #   df.plot :a, :b, type: :bar, title: "Awesome plot"
-      def plot x, y, opts={}
+      #   df.plot legends: [:a, :b], type: :bar
+      def plot opts={}
         options = {
           type:  :scatter,
-          title: "#{@name}",
+          frame: false,
+          legends: []
         }.merge(opts)
 
         plot = Nyaplot::Plot.new
-        p    = plot.add_with_df(Nyaplot::DataFrame.new(self.to_a[0]), options[:type], x, y)
-        plot.x_label options[:x_label]                if options[:x_label]
-        plot.y_label options[:y_label]                if options[:y_label]
-        p.tooltip_contents options[:tooltip_contents] if options[:tooltip_contents]
+        diagram = plot.add_with_df(Nyaplot::DataFrame.new(self.to_a[0]), 
+          options[:type], *options[:legends])
 
-        if options[:fill_by] or options[:shape_by]
-          p.color Nyaplot::Colors.qual
-          p.fill_by  options[:fill_by]  if options[:fill_by]
-          p.shape_by options[:shape_by] if options[:shape_by]
-        end
+        yield(plot, diagram) if block_given?
 
-        plot.show
+        plot.show unless options[:frame]
       end
     end
   end

data/lib/daru/plotting/vector.rb

@@ -8,32 +8,31 @@ module Daru
   module Plotting
     module Vector
 
-      # Plots a Vector with Nyaplot on IRuby using the given options.
+      # 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 
+      # 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, title: "My first plot", color: true
-      def plot opts={}
+      #   vector.plot(type: :bar) do |plot|
+      #     plot.title "My first plot"
+      #     plot.width 1200
+      #   end
+      def plot opts={}, &block
         options = {
-          type: :scatter,
-          title: "#{@name}",
-          x_label: '',
-          y_label: '',
-          color: false
+          type: :scatter
         }.merge(opts)
 
         x_axis = options[:type] == :scatter ? Array.new(@size) { |i| i } : @index.to_a
         plot   = Nyaplot::Plot.new
-        plot.width(options[:width])   if options[:width]
-        plot.height(options[:height]) if options[:height]
-        
-        p      = plot.add( options[:type], x_axis, @vector.to_a )
-        plot.x_label( options[:x_label] )  if options[:x_label]
-        plot.y_label( options[:y_label] )  if options[:y_label]
-        p.color( Nyaplot::Colors.qual )    if options[:color]
+        diagram = plot.add( options[:type], x_axis, @data.to_a )
 
+        yield plot, diagram if block_given?
+        
         plot.show
       end
     end

data/lib/daru/vector.rb

@@ -14,17 +14,23 @@ module Daru
     include Daru::Plotting::Vector
 
     def each(&block)
-      @vector.each(&block)
+      return to_enum(:each) unless block_given?
+      
+      @data.each(&block)
+      self
     end
 
     def map!(&block)
-      @vector.map!(&block)
+      return to_enum(:map!) unless block_given?
 
+      @data.map!(&block)
       self
     end
 
     def map(&block)
-      Daru::Vector.new @vector.map(&block), name: @name, index: @index, dtype: @dtype
+      return to_enum(:map) unless block_given?
+
+      Daru::Vector.new @data.map(&block), name: @name, index: @index, dtype: @dtype
     end
 
     alias_method :recode, :map
@@ -33,22 +39,29 @@ module Daru
     attr_reader :index
     attr_reader :size
     attr_reader :dtype
+    attr_reader :nm_dtype
+    attr_reader :nil_positions
 
     # 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.
+    #   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
     # 
-    # * +:name+ - Name of the vector
+    # * +:name+  - Name of the vector
+    # 
+    # * +:index+ - Index of the vector
     # 
-    # * +:index+ -  Index of the vector
+    # * +:dtype+ - The underlying data type. Can be :array or :nmatrix. Default :array.
+    # 
+    # * +:nm_dtype+ - For NMatrix, the data type of the numbers. See the NMatrix docs for
+    #     further information on supported data type.
     # 
     # == Usage
     # 
@@ -64,76 +77,112 @@ module Daru
         source = source || []
       end
       name   = opts[:name]
-      @dtype = opts[:dtype] || Array
-
       set_name name
 
-      @vector = 
-      case
-      when @dtype == Array
-        Daru::Accessors::ArrayWrapper.new source.dup, self
-      when @dtype == NMatrix
-        Daru::Accessors::NMatrixWrapper.new source.dup, self
-      when @dtype == MDArray
-        Daru::Accessors::MDArrayWrapper.new source.dup
-      when @dtype == Range, Matrix
-        Daru::Accessors::ArrayWrapper.new source.to_a.dup, self
-      end
-
-      if index.nil?
-        @index = Daru::Index.new @vector.size  
-      else
-        @index = index.to_index
-      end
-      # TODO: Will need work for NMatrix/MDArray
-      if @index.size > @vector.size
-        self.coerce Array # NM with nils seg faults
-        (@index.size - @vector.size).times { @vector << nil }
-      elsif @index.size < @vector.size
-        raise IndexError, "Expected index size >= vector size"
+      @data  = cast_vector_to(opts[:dtype], source, opts[:nm_dtype])
+      @index = create_index(index || @data.size)
+      
+      if @index.size > @data.size
+        cast(dtype: :array) # NM with nils seg faults
+        (@index.size - @data.size).times { @data << nil }
+      elsif @index.size < @data.size
+        raise IndexError, "Expected index size >= vector size. Index size : #{@index.size}, vector size : #{@data.size}"
       end
 
+      @possibly_changed_type = true
+      set_nil_positions
       set_size
     end
 
-    # Get one or more elements with specified index.
+    # Get one or more elements with specified index or a range.
     # 
     # == Usage
+    #   # For vectors employing single layer Index
+    # 
     #   v[:one, :two] # => Daru::Vector with indexes :one and :two
     #   v[:one]       # => Single element
-    def [](index, *indexes)
-      if indexes.empty?
-        case index
-        when Range
-          # range into vector
-          # 
+    #   v[:one..:three] # => Daru::Vector with indexes :one, :two and :three
+    # 
+    #   # For vectors employing hierarchial multi index
+    #   
+    def [](*indexes)
+      location = indexes[0]
+      if @index.is_a?(MultiIndex)
+        result = 
+        if location.is_a?(Integer)
+          element_from_numeric_index(location)
+        elsif location.is_a?(Range)
+          arry = location.inject([]) do |memo, num|
+            memo << element_from_numeric_index(num)
+            memo
+          end
+
+          new_index = Daru::MultiIndex.new(@index.to_a[location])
+          Daru::Vector.new(arry, index: new_index, name: @name, dtype: dtype)
         else
-          if @index.include? index
-            @vector[@index[index]]
-          elsif index.is_a?(Numeric)
-            @vector[index]
+          sub_index = @index[indexes]
+
+          if sub_index.is_a?(Integer)
+            element_from_numeric_index(sub_index)
           else
-            return nil
+            elements = sub_index.map do |tuple|
+              @data[@index[(indexes + tuple)]]
+            end
+            Daru::Vector.new(elements, index: Daru::MultiIndex.new(sub_index.to_a),
+              name: @name, dtype: @dtype)
           end
         end
+
+        return result
       else
-        indexes.unshift index
+        unless indexes[1]
+          case location
+          when Range
+            range = 
+            if location.first.is_a?(Numeric)
+              location
+            else
+              first = location.first
+              last  = location.last
+
+              (first..last)
+            end
+            indexes = @index[range]
+          else
+            return element_from_numeric_index(location)
+          end
+        end
 
-        Daru::Vector.new indexes.map { |index| @vector[@index[index]] },name: @name, 
-          index: indexes
+        Daru::Vector.new indexes.map { |loc| @data[index_for(loc)] }, name: @name, 
+          index: indexes.map { |e| named_index_for(e) }, dtype: @dtype
       end
     end
 
-    def []=(index, value)
-      @vector = @vector.coerce(Array) if value.nil?
+    def []=(*location, value)
+      cast(dtype: :array) if value.nil? and dtype != :array
 
-      if @index.include? index
-        @vector[@index[index]] = value
+      @possibly_changed_type = true if @type == :object  and (value.nil? or 
+        value.is_a?(Numeric))
+      @possibly_changed_type = true if @type == :numeric and (!value.is_a?(Numeric) and
+        !value.nil?)
+
+      pos =
+      if @index.is_a?(MultiIndex) and !location[0].is_a?(Integer)
+        index_for location
+      else
+        index_for location[0]
+      end
+
+      if pos.is_a?(MultiIndex)
+        pos.each do |sub_tuple|
+          self[*(location + sub_tuple)] = value
+        end
       else
-        @vector[index] = value
+        @data[pos] = value
       end
 
       set_size
+      set_nil_positions
     end
 
     # Two vectors are equal if the have the exact same index values corresponding
@@ -158,8 +207,12 @@ module Daru
       concat element  
     end
 
-    def re_index new_index
-      
+    def head q=10
+      self[0..q]
+    end
+
+    def tail q=10
+      self[-q..-1]
     end
 
     # Append an element to the vector by specifying the element and index
@@ -167,30 +220,31 @@ module Daru
       raise IndexError, "Expected new unique index" if @index.include? index
 
       if index.nil? and @index.index_class == Integer
-        @index = Daru::Index.new @size+1
+        @index = create_index(@size + 1)
         index  = @size
       else
         begin
-          @index = @index.re_index(@index + index)
-        rescue Exception => e
+          @index = create_index(@index + index)
+        rescue StandardError => e
           raise e, "Expected valid index."
         end
       end
-
-      @vector[@index[index]] = element
-
+      @data[@index[index]] = element
       set_size
+      set_nil_positions
     end
 
-    def coerce dtype
-      begin
-        @vector = @vector.coerce @dtype
-        @dtype  = dtype
-      rescue StandardError => e
-        puts "Cannot convert to #{dtype} because of data type mismatch. #{e}"
-      end
+    # Cast a vector to a new data type.
+    # 
+    # == Options
+    # 
+    # * +:dtype+ - :array for Ruby Array. :nmatrix for NMatrix.
+    def cast opts={}
+      dtype = opts[:dtype]
+      raise ArgumentError, "Unsupported dtype #{opts[:dtype]}" unless 
+        dtype == :array or dtype == :nmatrix
 
-      self
+      @data = cast_vector_to dtype
     end
 
     # Delete an element by value
@@ -201,25 +255,51 @@ module Daru
     # Delete element by index
     def delete_at index
       idx = named_index_for index
-      @vector.delete_at @index[idx]
+      @data.delete_at @index[idx]
 
       if @index.index_class == Integer
         @index = Daru::Index.new @size-1
       else
-        @index = (@index.to_a - [idx]).to_index
+        @index = Daru::Index.new (@index.to_a - [idx])
       end
 
       set_size
+      set_nil_positions
+    end
+
+    # The type of data contained in the vector. Can be :object or :numeric. If
+    # the underlying dtype is an NMatrix, this method will return the data type
+    # of the NMatrix object.
+    #   
+    # Running through the data to figure out the kind of data is delayed to the
+    # last possible moment.    
+    def type
+      return @data.nm_dtype if dtype == :nmatrix
+
+      if @type.nil? or @possibly_changed_type
+        @type = :numeric
+        self.each do |e|
+          unless e.nil?
+            unless e.is_a?(Numeric)
+              @type = :object
+              break
+            end
+          end
+        end
+        @possibly_changed_type = false
+      end
+
+      @type
     end
 
     # Get index of element
     def index_of element
-      @index.key @vector.index(element)
+      @index.key @data.index(element)
     end
 
     # Keep only unique elements of the vector alongwith their indexes.
     def uniq
-      uniq_vector = @vector.uniq
+      uniq_vector = @data.uniq
       new_index   = uniq_vector.inject([]) do |acc, element|  
         acc << index_of(element) 
         acc
@@ -228,21 +308,123 @@ module Daru
       Daru::Vector.new uniq_vector, name: @name, index: new_index, dtype: @dtype
     end
 
-    # def sort ascending=true
-    #   if ascending
-        
-    #   end
-    # 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.
+    # 
+    # == Options
+    # 
+    # * +:ascending+ - if false, will sort in descending order. Defaults to true.
+    # 
+    # * +:type+ - Specify the sorting algorithm. Only supports quick_sort for now.
+    # == Usage
+    # 
+    #   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 }
+    def sort opts={}, &block
+      opts = {
+        ascending: true,
+        type: :quick_sort
+      }.merge(opts)
+
+      block = lambda { |a,b| a <=> b } unless block
+    
+      order = opts[:ascending] ? :ascending : :descending
+      vector, index = send(opts[:type], @data.to_a.dup, @index.to_a, order, &block)
+      index = @index.is_a?(MultiIndex) ? Daru::MultiIndex.new(index) : index
+
+      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.
+    def sorted_data &block
+      @data.to_a.sort(&block)
+    end
 
-    def is_valid? value
+    # Returns *true* if the value passed actually exists in the vector.
+    def exists? value
       !self[index_of(value)].nil?
     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?
+      nil_truth_vector = clone_structure
+      @index.each do |idx|
+        nil_truth_vector[idx] = self[idx].nil? ? true : false
+      end
+
+      nil_truth_vector
+    end
+
+    # Opposite of #is_nil?
+    def not_nil?
+      nil_truth_vector = clone_structure
+      @index.each do |idx|
+        nil_truth_vector[idx] = self[idx].nil? ? false : true
+      end
+
+      nil_truth_vector
+    end
+
+    # Replace all nils in the vector with the value passed as an argument. Destructive.
+    #   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|
+        self[idx] = replacement
+      end
+
+      self
+    end
+
+    # Non-destructive version of #replace_nils!
+    def replace_nils replacement
+      self.dup.replace_nils!(replacement)
+    end
+
+    def n_valid
+      @size
+    end
+
     # Returns *true* if an index exists
     def has_index? index
       @index.include? index
     end
 
+    # Convert Vector to a horizontal or vertical Ruby Matrix.
+    # 
+    # == Arguments
+    # 
+    # * +axis+ - Specify whether you want a *:horizontal* or a *:vertical* matrix.
+    def to_matrix axis=:horizontal
+      if axis == :horizontal
+        Matrix[to_a]
+      elsif axis == :vertical
+        Matrix.columns([to_a])
+      else
+        raise ArgumentError, "axis should be either :horizontal or :vertical, not #{axis}"
+      end
+    end
+
     # Convert to hash. Hash keys are indexes and values are the correspoding elements
     def to_hash
       @index.inject({}) do |hsh, index|
@@ -253,7 +435,7 @@ module Daru
 
     # Return an array
     def to_a
-      @vector.to_a
+      @data.to_a
     end
 
     # Convert the hash from to_hash to json
@@ -283,10 +465,10 @@ module Daru
     end
 
     # Over rides original inspect for pretty printing in irb
-    def inspect spacing=10, threshold=15
+    def inspect spacing=20, threshold=15
       longest = [@name.to_s.size,
                  @index.to_a.map(&:to_s).map(&:size).max, 
-                 @vector    .map(&:to_s).map(&:size).max,
+                 @data    .map(&:to_s).map(&:size).max,
                  'nil'.size].max
 
       content   = ""
@@ -297,7 +479,7 @@ module Daru
 
       content += sprintf formatter, "", name
       @index.each_with_index do |index, num|
-        content += sprintf formatter, index.to_s, (self[index] || 'nil').to_s
+        content += sprintf formatter, index.to_s, (self[*index] || 'nil').to_s
         if num > threshold
           content += sprintf formatter, '...', '...'
           break
@@ -308,27 +490,38 @@ module Daru
       content
     end
 
-    # def compact!
-      # TODO: Compact and also take care of indexes
-      # @vector.compact!
-      # set_size
-    # end
+    # Create a new vector with a different index.
+    # 
+    # @param new_index [Symbol, Array, Daru::Index] The new index. Passing *:seq*
+    #   will reindex with sequential numbers from 0 to (n-1).
+    def reindex new_index
+      index = create_index(new_index == :seq ? @size : new_index)
+      Daru::Vector.new @data.to_a, index: index, name: name, dtype: @dtype
+    end
 
     # Give the vector a new name
+    # 
+    # @param new_name [Symbol] The new name.
     def rename new_name
       @name = new_name.to_sym
     end
 
     # Duplicate elements and indexes
     def dup 
-      Daru::Vector.new @vector.dup, name: @name, index: @index.dup
+      Daru::Vector.new @data.dup, name: @name, index: @index.dup
+    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)
     end
 
     def daru_vector *name
       self
     end
 
-    alias_method :dv, :daru_vector
+    alias :dv :daru_vector
 
     def method_missing(name, *args, &block)
       if name.match(/(.+)\=/)
@@ -342,6 +535,88 @@ module Daru
 
    private
 
+    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
+      return false if a.nil? or b.nil?
+      eval = block.call(a,b)
+      if order == :ascending 
+        return true  if eval == -1
+        return false if eval == 1
+      elsif order == :descending
+        return false if eval == -1
+        return true  if eval == 1
+      end
+      return false
+    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.
+    def cast_vector_to dtype, source=nil, nm_dtype=nil
+      source = @data if source.nil?
+      return @data if @dtype and @dtype == dtype
+
+      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 :mdarray then raise NotImplementedError, "MDArray not yet supported."
+      else Daru::Accessors::ArrayWrapper.new(source.dup, self)
+      end
+
+      @dtype = dtype || :array
+      new_vector
+    end
+
     def named_index_for index
       if @index.include? index
         index
@@ -352,18 +627,47 @@ module Daru
       end
     end
 
+    def index_for index
+      if @index.include?(index)
+        @index[index]
+      elsif index.is_a?(Numeric)
+        index
+      end
+    end
+
     def set_size
-      @size = @vector.size
+      @size = @data.size
     end
 
     def set_name name
-      if name.is_a?(Numeric)
-        @name = name 
-      elsif name # anything but Numeric or nil
-        @name = name.to_sym
+      @name = 
+      if name.is_a?(Numeric)  then name 
+      elsif name.is_a?(Array) then name.join.to_sym # in case of MultiIndex tuple
+      elsif name              then name.to_sym # anything but Numeric or nil
       else
-        @name = nil
+        nil
       end
     end
+
+    def set_nil_positions
+      @nil_positions = []
+      @index.each do |e|
+        @nil_positions << e if(self[e].nil?)
+      end
+      @nil_positions.uniq!
+    end
+
+    def create_index potential_index
+      if potential_index.is_a?(Daru::MultiIndex) or potential_index.is_a?(Daru::Index)
+        potential_index
+      else
+        Daru::Index.new(potential_index)
+      end
+    end
+
+    def element_from_numeric_index location
+      pos = index_for location
+      pos ? @data[pos] : nil
+    end
   end
 end