daru 0.0.4 → 0.0.5

data/lib/daru/core/group_by.rb

@@ -0,0 +1,183 @@
+module Daru
+  module Core
+    class GroupBy
+
+      attr_reader :groups
+
+      def initialize context, names
+        @groups = {}
+        @non_group_vectors = context.vectors.to_a - names
+        @context = context
+        vectors = names.map { |vec| context.vector[vec].to_a }
+        tuples  = vectors[0].zip(*vectors[1..-1])
+        keys    = tuples.uniq.sort
+
+        keys.each do |key|
+          @groups[key] = all_indices_for(tuples, key)
+        end
+        @groups.freeze
+      end
+
+      def size
+        index = 
+        if multi_indexed_grouping?
+          Daru::MultiIndex.new symbolize(@groups.keys)
+        else
+          Daru::Index.new symbolize(@groups.keys.flatten)
+        end
+
+        values = @groups.values.map { |e| e.size }
+        Daru::Vector.new(values, index: index, name: :size)
+      end
+
+      def first
+        head(1)
+      end
+
+      def last
+        tail(1)
+      end
+
+      def head quantity=5
+        select_groups_from :first, quantity
+      end
+
+      def tail quantity=5
+        select_groups_from :last, quantity
+      end
+
+      # Calculate mean of numeric groups, excluding missing values.
+      def mean
+        apply_method :numeric, :mean
+      end
+
+      # Calculate the median of numeric groups, excluding missing values.
+      def median
+        apply_method :numeric, :median
+      end
+
+      # Calculate sum of numeric groups, excluding missing values.
+      def sum
+        apply_method :numeric, :sum
+      end
+
+      def count
+        width = @non_group_vectors.size
+        Daru::DataFrame.new([size]*width, order: @non_group_vectors)
+      end
+
+      # Calculate sample standard deviation of numeric vector groups, excluding 
+      # missing values.
+      def std
+        apply_method :numeric, :std
+      end
+
+      # Find the max element of each numeric vector group.
+      def max
+        apply_method :numeric, :max
+      end
+
+      # Find the min element of each numeric vector group.
+      def min
+        apply_method :numeric, :min
+      end
+
+      # Returns one of the selected groups as a DataFrame.
+      def get_group group
+        indexes   = @groups[group]
+        elements  = []
+
+        @context.each_vector do |vector|
+          elements << vector.to_a
+        end
+        rows = []
+        transpose = elements.transpose
+
+        indexes.each do |idx|
+          rows << transpose[idx]
+        end
+        Daru::DataFrame.rows(rows, index: @context.index[indexes], order: @context.vectors)
+      end
+
+     private 
+
+      def select_groups_from method, quantity
+        selection     = @context
+        rows, indexes = [], []
+
+        @groups.each_value do |index|
+          index.send(method, quantity).each do |idx|
+            rows << selection.row[idx].to_a
+            indexes << idx
+          end
+        end
+        indexes.flatten!
+
+        Daru::DataFrame.rows(rows, order: @context.vectors, index: indexes)
+      end
+
+      def apply_method method_type, method
+        multi_index = multi_indexed_grouping?
+        rows, order = [], []
+
+        @groups.each do |group, indexes|
+          single_row = []
+          @non_group_vectors.each do |ngvector|
+            vector = @context.vector[ngvector]
+            if method_type == :numeric and vector.type == :numeric
+              slice = vector[*indexes]
+
+              single_row << (slice.is_a?(Numeric) ? slice : slice.send(method))
+              order << ngvector
+            end
+          end 
+
+          rows << single_row
+        end
+
+        index = symbolize @groups.keys
+        index = multi_index ? Daru::MultiIndex.new(index) : Daru::Index.new(index.flatten)
+        order = symbolize order
+        order = 
+        if order.all?{ |e| e.is_a?(Array) }
+          Daru::MultiIndex.new(order)
+        else
+          Daru::Index.new(order)
+        end
+
+        Daru::DataFrame.new(rows.transpose, index: index, order: order)
+      end
+
+      def all_indices_for arry, element
+        found, index, indexes = -1, -1, []
+        while found
+          found = arry[index+1..-1].index(element)
+          if found
+            index = index + found + 1
+            indexes << index
+          end
+        end
+        indexes
+      end
+
+      def symbolize arry
+        symbolized_arry =
+        if arry.all? { |e| e.is_a?(Array) }
+          arry.map do |sub_arry|
+            sub_arry.map do |e|
+              e.is_a?(Numeric) ? e : e.to_sym
+            end
+          end
+        else
+          arry.map { |e| e.is_a?(Numeric) ? e : e.to_sym }
+        end
+
+        symbolized_arry
+      end
+
+      def multi_indexed_grouping?
+        @groups.keys[0][1] ? true : false
+      end
+    end
+  end
+end

data/lib/daru/dataframe.rb

@@ -1,9 +1,11 @@
-require_relative 'accessors/dataframe_by_row.rb'
-require_relative 'accessors/dataframe_by_vector.rb'
-require_relative 'maths/arithmetic/dataframe.rb'
-require_relative 'maths/statistics/dataframe.rb'
-require_relative 'plotting/dataframe.rb'
-require_relative 'io/io.rb'
+$:.unshift File.dirname(__FILE__)
+
+require 'accessors/dataframe_by_row.rb'
+require 'accessors/dataframe_by_vector.rb'
+require 'maths/arithmetic/dataframe.rb'
+require 'maths/statistics/dataframe.rb'
+require 'plotting/dataframe.rb'
+require 'io/io.rb'
 
 module Daru
   class DataFrame
@@ -14,7 +16,7 @@ module Daru
 
     class << self
       # Load data from a CSV file. 
-      # Arguments - path, options, block(optional)
+      #   Arguments - path, options, block(optional)
       # 
       # Accepts a block for pre-conditioning of CSV data if any.
       def from_csv path, opts={}, &block
@@ -24,25 +26,25 @@ module Daru
       # Create DataFrame by specifying rows as an Array of Arrays or Array of
       # Daru::Vector objects.
       def rows source, opts={}
+        df = nil
         if source.all? { |v| v.size == source[0].size }
           first = source[0]
           index = []
-          order =
-          unless opts[:order]
-            if first.is_a?(Daru::Vector) # assume that all are Vectors only
-              source.each { |vec| index << vec.name }
-              first.index.to_a
-            elsif first.is_a?(Array)
-              Array.new(first.size) { |i| i.to_s }
-            end
-          else
-            opts[:order]
+          opts[:order] ||=
+          if first.is_a?(Daru::Vector) # assume that all are Vectors
+            source.each { |vec| index << vec.name }
+            first.index.to_a
+          elsif first.is_a?(Array)
+            Array.new(first.size) { |i| i.to_s }
           end
 
-          opts[:order] = order
-          df           = Daru::DataFrame.new({}, opts)
-          source.each_with_index do |row,idx|
-            df[(index[idx] || idx), :row] = row
+          if source.all? { |s| s.is_a?(Array) }
+            df = Daru::DataFrame.new(source.transpose, opts)
+          else # array of Daru::Vectors
+            df = Daru::DataFrame.new({}, opts)
+            source.each_with_index do |row, idx|
+              df[(index[idx] || idx), :row] = row
+            end
           end
         else
           raise SizeError, "All vectors must have same length"
@@ -65,8 +67,8 @@ module Daru
     attr_reader :size
 
     # DataFrame basically consists of an Array of Vector objects.
-    # These objects are indexed by row and column by vectors and index Index objects.
-    # Arguments - source, vectors, index, name.
+    #   These objects are indexed by row and column by vectors and index Index objects.
+    #   Arguments - source, vectors, index, name.
     # 
     # == Usage
     #   df = Daru::DataFrame.new({a: [1,2,3,4], b: [6,7,8,9]}, order: [:b, :a], 
@@ -82,43 +84,55 @@ module Daru
     def initialize source, opts={}
       vectors = opts[:order]
       index   = opts[:index]
-      @dtype  = opts[:dtype] || Array
       @name   = (opts[:name] || SecureRandom.uuid).to_sym
       @data   = []
 
       if source.empty?
-        @vectors = Daru::Index.new vectors
-        @index   = Daru::Index.new index
+        @vectors = create_index vectors
+        @index   = create_index index
         create_empty_vectors
       else
         case source
         when Array
-          if vectors.nil?
-            @vectors = Daru::Index.new source[0].keys.map(&:to_sym)
-          else
-            @vectors = Daru::Index.new (vectors + (source[0].keys - vectors)).uniq.map(&:to_sym)
-          end
+          if source.all? { |s| s.is_a?(Array) }
+            raise ArgumentError, "Number of vectors (#{vectors.size}) should \
+              equal order size (#{source.size})" if source.size != vectors.size
 
-          if index.nil?
-            @index = Daru::Index.new source.size
-          else
-            @index = Daru::Index.new index
-          end
+            @index   = create_index(index || source[0].size)
+            @vectors = create_index(vectors)
 
-          @vectors.each do |name|
-            v = []
-            source.each do |hsh|
-              v << (hsh[name] || hsh[name.to_s])
+            @vectors.each_with_index do |vec,idx|
+              @data << Daru::Vector.new(source[idx], index: @index)
+            end
+          elsif source.all? { |s| s.is_a?(Daru::Vector) }
+            hsh = {}
+            vectors.each_with_index do |name, idx|
+              hsh[name] = source[idx]
+            end
+            initialize(hsh, index: index, order: vectors, name: @name)
+          else # array of hashes
+            if vectors.nil?
+              @vectors = Daru::Index.new source[0].keys.map(&:to_sym)
+            else
+              @vectors = Daru::Index.new (vectors + (source[0].keys - vectors)).uniq.map(&:to_sym)
             end
+            @index = Daru::Index.new(index || source.size)
+
+            @vectors.each do |name|
+              v = []
+              source.each do |hsh|
+                v << (hsh[name] || hsh[name.to_s])
+              end
 
-            @data << v.dv(name, @index, @dtype)
+              @data << Daru::Vector.new(v, name: set_name(name), index: @index)
+            end
           end
         when Hash
           create_vectors_index_with vectors, source
           if all_daru_vectors_in_source? source
             if !index.nil?
-              @index = index.to_index
-            elsif all_vectors_have_equal_indexes? source
+              @index = create_index index
+            elsif all_vectors_have_equal_indexes?(source)
               @index = source.values[0].index.dup
             else
               all_indexes = []
@@ -131,29 +145,17 @@ module Daru
               @index = Daru::Index.new all_indexes
             end
             @vectors.each do |vector|
-              @data << Daru::Vector.new([], name: vector, index: @index, dtype: @dtype)
+              @data << Daru::Vector.new([], name: vector, index: @index)
 
               @index.each do |idx|
-                begin
-                  @data[@vectors[vector]][idx] = source[vector][idx]                   
-                rescue IndexError
-                  # If the index is not present in the vector under consideration
-                  # (in source) then an error is raised. Put a nil in that place if
-                  # that is the case.
-                  @data[@vectors[vector]][idx] = nil                  
-                end
+                @data[@vectors[vector]][idx] = source[vector][idx]
               end
             end
-          else   
-            index = source.values[0].size if index.nil?
-            if index.is_a?(Daru::Index)
-              @index   = index.to_index
-            else
-              @index   = Daru::Index.new index     
-            end
+          else
+            @index = create_index(index || source.values[0].size)
 
             @vectors.each do |name|
-              @data << source[name].dup.dv(name, @index, @dtype)
+              @data << Daru::Vector.new(source[name].dup, name: set_name(name), index: @index)
             end
           end
         end
@@ -164,10 +166,17 @@ module Daru
     end
 
     # Access row or vector. Specify name of row/vector followed by axis(:row, :vector).
-    # Use of this method is not recommended for accessing rows or vectors.
-    # Use df.row[:a] for accessing row with index ':a' or df.vector[:vec] for
-    # accessing vector with index ':vec'
-    def [](*names, axis)
+    # Defaults to *:vector*. Use of this method is not recommended for accessing 
+    # rows or vectors. Use df.row[:a] for accessing row with index ':a' or 
+    # df.vector[:vec] for accessing vector with index *:vec*.
+    def [](*names)
+      if names[-1] == :vector or names[-1] == :row
+        axis = names[-1]
+        names = names[0..-2]
+      else
+        axis = :vector
+      end
+
       if axis == :vector
         access_vector *names
       elsif axis == :row
@@ -184,7 +193,12 @@ module Daru
     # In case a Daru::Vector is specified after the equality the sign, the indexes
     # of the vector will be matched against the row/vector indexes of the DataFrame
     # before an insertion is performed. Unmatched indexes will be set to nil.
-    def []=(name, axis ,vector)
+    def []=(*args)
+      name   = args[0]
+      axis   = args[1]
+      vector = args[-1]
+
+      axis = (!axis.is_a?(Symbol) and (axis != :vector or axis != :row)) ? :vector : axis
       if axis == :vector
         insert_or_modify_vector name, vector
       elsif axis == :row        
@@ -203,6 +217,11 @@ module Daru
       Daru::Accessors::DataFrameByVector.new(self)
     end
 
+    # Access a vector by name.
+    def column name
+      vector[name]
+    end
+
     # Access a row or set/create a row. Refer #[] and #[]= docs for details.
     # 
     # == Usage
@@ -219,18 +238,24 @@ module Daru
         src[vector] = @data[@vectors[vector]].dup
       end
 
-      Daru::DataFrame.new src, order: @vectors.dup, index: @index.dup, name: @name, dtype: @dtype
+      Daru::DataFrame.new src, order: @vectors.dup, index: @index.dup, name: @name
     end
 
     # Iterate over each vector
     def each_vector(&block)
+      return to_enum(:each_vector) unless block_given?
+
       @data.each(&block)
 
       self
     end
 
+    alias_method :each_column, :each_vector
+
     # Iterate over each vector alongwith the name of the vector
     def each_vector_with_index(&block)
+      return to_enum(:each_vector_with_index) unless block_given?
+
       @vectors.each do |vector|
         yield @data[@vectors[vector]], vector
       end 
@@ -238,8 +263,12 @@ module Daru
       self
     end
 
+    alias_method :each_column_with_index, :each_vector_with_index
+
     # Iterate over each row
     def each_row(&block)
+      return to_enum(:each_row) unless block_given?
+
       @index.each do |index|
         yield access_row(index)
       end
@@ -248,6 +277,8 @@ module Daru
     end
 
     def each_row_with_index(&block)
+      return to_enum(:each_row_with_index) unless block_given?
+
       @index.each do |index|
         yield access_row(index), index
       end
@@ -256,17 +287,27 @@ module Daru
     end
 
     # Map each vector. Returns a DataFrame whose vectors are modified according
-    # to the value returned by the block.
+    # to the value returned by the block. As is the case with Enumerable#map,
+    # the object returned by each block must be a Daru::Vector for the dataframe
+    # to remain relevant.
     def map_vectors(&block)
-      df = self.dup
-      df.each_vector_with_index do |vector, name|
-        df[name, :vector] = yield(vector)
-      end
+      return to_enum(:map_vectors) unless block_given?
 
-      df
+      self.dup.map_vectors!(&block)
     end
 
+    # Destructive form of #map_vectors
+    def map_vectors!(&block)
+      return to_enum(:map_vectors!) unless block_given?
+
+      @data.map!(&block)
+      self
+    end
+
+    # Map vectors alongwith the index.
     def map_vectors_with_index(&block)
+      return to_enum(:map_vectors_with_index) unless block_given?
+
       df = self.dup
       df.each_vector_with_index do |vector, name|
         df[name, :vector] = yield(vector, name)
@@ -277,6 +318,8 @@ module Daru
 
     # Map each row
     def map_rows(&block)
+      return to_enum(:map_rows) unless block_given?
+
       df = self.dup
       df.each_row_with_index do |row, index|
         df[index, :row] = yield(row)
@@ -286,6 +329,8 @@ module Daru
     end
 
     def map_rows_with_index(&block)
+      return to_enum(:map_rows_with_index) unless block_given?
+
       df = self.dup
       df.each_row_with_index do |row, index|
         df[index, :row] = yield(row, index)
@@ -302,13 +347,16 @@ module Daru
       else
         raise IndexError, "Vector #{vector} does not exist."
       end
+
+      self
     end
 
+    # Delete a row
     def delete_row index
       idx = named_index_for index
 
       if @index.include? idx
-        @index = (@index.to_a - [idx]).to_index
+        @index = reassign_index_as(@index.to_a - [idx])
         self.each_vector do |vector|
           vector.delete_at idx
         end
@@ -343,6 +391,8 @@ module Daru
     # Iterates over each row and retains it in a new DataFrame if the block returns
     # true for that row.
     def filter_rows &block
+      return to_enum(:filter_rows) unless block_given?
+
       df = Daru::DataFrame.new({}, order: @vectors.to_a)
       marked = []
 
@@ -361,39 +411,255 @@ module Daru
     # Iterates over each vector and retains it in a new DataFrame if the block returns
     # true for that vector.
     def filter_vectors &block
+      return to_enum(:filter_vectors) unless block_given?
+      
       df = self.dup
       df.keep_vector_if &block
 
       df
     end
 
+    # Return the number of rows and columns of the DataFrame in an Array.
+    def shape
+      [@index.size, @vectors.size]
+    end
+
+    # The number of rows
+    def rows
+      shape[0]
+    end
+
+    # The number of vectors
+    def cols
+      shape[1]
+    end
+
     # Check if a vector is present
-    def has_vector? name
-      !!@vectors[name]
+    def has_vector? vector
+      !!@vectors[*vector]
     end
 
+    # The first ten elements of the DataFrame
+    #
+    # @param [Fixnum] quantity (10) The number of elements to display from the top.
     def head quantity=10
       self[0..quantity, :row]
     end
 
+    # The last ten elements of the DataFrame
+    # 
+    # @param [Fixnum] quantity (10) The number of elements to display from the bottom.
     def tail quantity=10
-      self[(@size - quantity)..@size, :row]
+      self[(@size - quantity)..(@size-1), :row]
     end
 
-    # def sort_by_row name
-      
-    # end
+    # Group elements by vector to perform operations on them.
+    def group_by vectors
+      vectors = [vectors] if vectors.is_a?(Symbol)
+      vectors.each { |v| raise(ArgumentError, "Vector #{v} does not exist") unless
+        has_vector?(v) }
+        
+      Daru::Core::GroupBy.new(self, vectors)
+    end
+
+    # Change the index of the DataFrame and its underlying vectors. Destructive.
+    # 
+    # @param [Symbol, Array] new_index Specify an Array if 
+    def reindex! new_index
+      raise ArgumentError, "Index size must equal dataframe size" if new_index.is_a?(Array) and new_index.size != @size
+
+      @index = possibly_multi_index?(new_index == :seq ? @size : new_index)
+      @data.map! do |vector|
+        vector.reindex possibly_multi_index?(@index.to_a)
+      end
+
+      self
+    end
+
+    # Non-destructive version of #reindex!
+    def reindex new_index
+      self.dup.reindex! new_index
+    end
+
+    # Return the names of all the numeric vectors. Will include vectors with nils
+    # alongwith numbers.
+    def numeric_vectors
+      numerics = []
+
+      each_vector do |vec|
+        numerics << vec.name if(vec.type == :numeric)
+      end
+      numerics
+    end
+
+    # Sorts a dataframe (ascending/descending)according to the given sequence of 
+    #   vectors, using the attributes provided in the blocks. Works for 2 LEVELS ONLY.
+    # 
+    # @param order [Array] The order of vector names in which the DataFrame
+    #   should be sorted.
+    # @param [Hash] opts The options to sort with.
+    # @option opts [TrueClass,FalseClass,Array] :ascending (true) Sort in ascending
+    #   or descending order. Specify Array corresponding to *order* for multiple
+    #   sort orders.
+    # @option opts [Hash] :by ({|a,b| a <=> b}) Specify attributes of objects to
+    #   to be used for sorting, for each vector name in *order* as a hash of 
+    #   vector name and lambda pairs. In case a lambda for a vector is not
+    #   specified, the default will be used.
+    # 
+    # == Usage
+    #   
+    #   df = Daru::DataFrame.new({a: [-3,2,-1,4], b: [4,3,2,1]})
+    #   
+    #   #<Daru::DataFrame:140630680 @name = 04e00197-f8d5-4161-bca2-93266bfabc6f @size = 4>
+    #   #            a          b 
+    #   # 0         -3          4 
+    #   # 1          2          3 
+    #   # 2         -1          2 
+    #   # 3          4          1 
+    #   df.sort([:a], by: { a: lambda { |a,b| a.abs <=> b.abs } })  
+    def sort! vector_order, opts={}
+      raise ArgumentError, "Required atleast one vector name" if vector_order.size < 1
+      opts = {
+        ascending: true,
+        type: :quick_sort,
+        by: {}
+      }.merge(opts)
+
+      opts[:by]        = create_logic_blocks vector_order, opts[:by]
+      opts[:ascending] = sort_order_array vector_order, opts[:ascending]
+      index = @index.to_a
+      send(opts[:type], vector_order, index, opts[:by], opts[:ascending])
+      reindex! index
+    end
+
+    # Non-destructive version of #sort!
+    def sort vector_order, opts={}
+      self.dup.sort! vector_order, opts
+    end
+
+    # Pivots a data frame on specified vectors and applies an aggregate function
+    # to quickly generate a summary.
+    # 
+    # == Options
+    # 
+    # +:index+ - Keys to group by on the pivot table row index. Pass vector names
+    # contained in an Array.
+    # 
+    # +:vectors+ - Keys to group by on the pivot table column index. Pass vector
+    # names contained in an Array.
+    # 
+    # +:agg+ - Function to aggregate the grouped values. Default to *:mean*. Can
+    # use any of the statistics functions applicable on Vectors that can be found in 
+    # the Daru::Statistics::Vector module.
+    # 
+    # +:values+ - Columns to aggregate. Will consider all numeric columns not 
+    # specified in *:index* or *:vectors*. Optional.
+    # 
+    # == Usage
+    # 
+    #   df = Daru::DataFrame.new({
+    #     a: ['foo'  ,  'foo',  'foo',  'foo',  'foo',  'bar',  'bar',  'bar',  'bar'], 
+    #     b: ['one'  ,  'one',  'one',  'two',  'two',  'one',  'one',  'two',  'two'],
+    #     c: ['small','large','large','small','small','large','small','large','small'],
+    #     d: [1,2,2,3,3,4,5,6,7],
+    #     e: [2,4,4,6,6,8,10,12,14]
+    #   })
+    #   df.pivot_table(index: [:a], vectors: [:b], agg: :sum, values: :e)
+    # 
+    #   #=> 
+    #   # #<Daru::DataFrame:88342020 @name = 08cdaf4e-b154-4186-9084-e76dd191b2c9 @size = 2>
+    #   #            [:e, :one] [:e, :two] 
+    #   #     [:bar]         18         26 
+    #   #     [:foo]         10         12 
+    def pivot_table opts={}
+      raise ArgumentError, "Specify grouping index" if !opts[:index] or opts[:index].empty?
 
-    # def sort_by_vector name
+      index   = opts[:index]
+      vectors = opts[:vectors] || []
+      aggregate_function = opts[:agg] || :mean
+      values = 
+      if opts[:values].is_a?(Symbol)
+        [opts[:values]]
+      elsif opts[:values].is_a?(Array)
+        opts[:values]
+      else # nil
+        (@vectors.to_a - (index | vectors)) & numeric_vectors
+      end
       
-    # end
+      raise IndexError, "No numeric vectors to aggregate" if values.empty?
+
+      grouped  = group_by(index)
+
+      unless vectors.empty?
+        super_hash = {}
+        values.each do |value|
+          grouped.groups.each do |group_name, row_numbers|
+            super_hash[group_name] ||= {}
+
+            row_numbers.each do |num|
+              arry = []
+              arry << value
+              vectors.each { |v| arry << self[v][num] }
+              sub_hash = super_hash[group_name]
+              sub_hash[arry] ||= []
+
+              sub_hash[arry] << self[value][num]
+            end
+          end
+        end
+
+        super_hash.each_value do |sub_hash|
+          sub_hash.each do |group_name, aggregates|
+            sub_hash[group_name] = Daru::Vector.new(aggregates).send(aggregate_function)
+          end
+        end
+
+        df_index = Daru::MultiIndex.new(symbolize(super_hash.keys))
+
+        vector_indexes = []
+        super_hash.each_value do |sub_hash|
+          vector_indexes.concat sub_hash.keys
+        end
+        df_vectors = Daru::MultiIndex.new symbolize(vector_indexes.uniq)
+        pivoted_dataframe = Daru::DataFrame.new({}, index: df_index, order: df_vectors)
+
+        super_hash.each do |row_index, sub_h|
+          sub_h.each do |vector_index, val|
+            pivoted_dataframe[symbolize(vector_index)][symbolize(row_index)] = val
+          end
+        end
+        return pivoted_dataframe
+      else
+        grouped.send(aggregate_function)
+      end
+    end
+
+    # Convert all vectors of type *:numeric* into a Matrix.
+    def to_matrix
+      numerics_as_arrays = []
+      each_vector do |vector|
+        numerics_as_arrays << vector.to_a if(vector.type == :numeric)
+      end
+
+      Matrix.columns numerics_as_arrays
+    end
+
+    # Convert all vectors of type *:numeric* and not containing nils into an NMatrix.
+    def to_nmatrix
+      numerics_as_arrays = []
+      each_vector do |vector|
+        numerics_as_arrays << vector.to_a if(vector.type == :numeric and 
+          vector.nil_positions.size == 0)
+      end
+
+      numerics_as_arrays.transpose.to_nm
+    end
     
     # Converts the DataFrame into an array of hashes where key is vector name
-    # and value is the corresponding element.
-    # The 0th index of the array contains the array of hashes while the 1th
-    # index contains the indexes of each row of the dataframe. Each element in
-    # the index array corresponds to its row in the array of hashes, which has
-    # the same index.
+    #   and value is the corresponding element. The 0th index of the array contains 
+    #   the array of hashes while the 1th index contains the indexes of each row 
+    #   of the dataframe. Each element in the index array corresponds to its row 
+    #   in the array of hashes, which has the same index.
     def to_a
       arry = [[],[]]
       self.each_row do |row|
@@ -443,7 +709,28 @@ module Daru
       to_html
     end
 
-    # Pretty print in a nice table format for the command line (irb)
+    # Change dtypes of vectors by supplying a hash of :vector_name => :new_dtype
+    # 
+    # == Usage
+    #   df = Daru::DataFrame.new({a: [1,2,3], b: [1,2,3], c: [1,2,3]})
+    #   df.recast a: :nmatrix, c: :nmatrix
+    def recast opts={}
+      opts.each do |vector_name, dtype|
+        vector[vector_name].cast(dtype: dtype)
+      end
+    end
+
+    # Transpose a DataFrame, tranposing elements and row, column indexing.
+    def transpose
+      arrys = []
+      each_vector do |vec|
+        arrys << vec.to_a
+      end
+
+      Daru::DataFrame.new(arrys.transpose, index: @vectors, order: @index, dtype: @dtype, name: @name)
+    end
+
+    # Pretty print in a nice table format for the command line (irb/pry/iruby)
     def inspect spacing=10, threshold=15
       longest = [@name.to_s.size,
                  @vectors.map(&:to_s).map(&:size).max, 
@@ -477,23 +764,14 @@ module Daru
       content
     end
 
-    def dtype= dtype
-      @dtype = dtype
-
-      @vectors.each do |vec|
-        pos = @vectors[vec]
-        @data[pos] = @data[pos].coerce(@dtype)
-      end
-    end
-
     def == other
-      @index == other.index and @size == other.size and @vectors.all? { |vector|
-                            self[vector, :vector] == other[vector, :vector] }
+      @index == other.index and @size == other.size and @vectors == other.vectors and 
+      @vectors.all? { |vector| self[vector, :vector] == other[vector, :vector] }
     end
 
     def method_missing(name, *args, &block)
       if md = name.match(/(.+)\=/)
-        insert_or_modify_vector name[/(.+)\=/].delete("="), args[0]
+        insert_or_modify_vector name[/(.+)\=/].delete("=").to_sym, args[0]
       elsif self.has_vector? name
         self[name, :vector]
       else
@@ -503,81 +781,234 @@ module Daru
 
    private
 
-    def access_vector *names
-      unless names[1]
-        if @vectors.include? names[0]
-          return @data[@vectors[names[0]]]
-        elsif @vectors.key names[0]
-          return @data[names[0]]
+    def possibly_multi_index? index
+      if @index.is_a?(MultiIndex)
+        Daru::MultiIndex.new(index)
+      else
+        Daru::Index.new(index)
+      end
+    end
+
+    def quick_sort vector_order, index, by, ascending
+      recursive_quick_sort vector_order, index, by, ascending, 0, @size-1
+    end
+
+    # == Arguments
+    # 
+    # vector_order - 
+    # index - 
+    # by -
+    # ascending -
+    # left_lower -
+    # right_upper -
+    def recursive_quick_sort vector_order, index, by, ascending, left_lower, right_upper
+      if left_lower < right_upper
+        left_upper, right_lower = partition(vector_order, index, by, ascending, left_lower, right_upper)
+        if left_upper - left_lower < right_upper - right_lower
+          recursive_quick_sort(vector_order, index, by, ascending, left_lower, left_upper)
+          recursive_quick_sort(vector_order, index, by, ascending, right_lower, right_upper)
         else
-          raise IndexError, "Specified index #{names[0]} does not exist."
+          recursive_quick_sort(vector_order, index, by, ascending, right_lower, right_upper)
+          recursive_quick_sort(vector_order, index, by, ascending, left_lower, left_upper)
         end
       end
-      new_vcs = {}
+    end
 
-      names.each do |name|
-        name = name.to_sym unless name.is_a?(Integer)
+    def partition vector_order, index, by, ascending, left_lower, right_upper
+      mindex = (left_lower + right_upper) / 2
+      mvalues = vector_order.inject([]) { |a, vector_name| a << vector[vector_name][mindex]; a }
+      i = left_lower
+      j = right_upper
+      descending = ascending.map { |a| !a }
+
+      i += 1 while(keep?(i, mvalues, vector_order, ascending , by, 0))
+      j -= 1 while(keep?(j, mvalues, vector_order, descending, by, 0))
+
+      while i < j - 1
+        @data.each do |vector|
+          vector[i], vector[j] = vector[j], vector[i]
+        end
+        index[i], index[j] = index[j], index[i]
+        i += 1
+        j -= 1
 
-        new_vcs[name] = @data[@vectors[name]]
+        i += 1 while(keep?(i, mvalues, vector_order, ascending , by,0))
+        j -= 1 while(keep?(j, mvalues, vector_order, descending, by,0))
       end
-      Daru::DataFrame.new new_vcs, order: new_vcs.keys, index: @index, name: @name
+
+      if i <= j
+        if i < j
+          @data.each do |vector|
+            vector[i], vector[j] = vector[j], vector[i]
+          end
+          index[i], index[j] = index[j], index[i]
+        end
+        i += 1
+        j -= 1
+      end
+
+      [j,i]
     end
 
-    def access_row *names
-      if names[1].nil?
-        access_token = names[0]
-        if access_token.is_a?(Range)
-          index_arry = @index.to_a
-
-          range = 
-          if access_token.first.is_a?(Numeric)
-            access_token
-          else
-            first_index = index_arry.index access_token.first
-            last_index  = index_arry.index access_token.last
+    def keep? current_index, mvalues, vector_order, sort_order, by, vector_order_index
+      vector_name = vector_order[vector_order_index]
+      if vector_name
+        vec = vector[vector_name]
+        eval = by[vector_name].call(vec[current_index], mvalues[vector_order_index])
+
+        if sort_order[vector_order_index] # sort in ascending order
+          return false if eval == 1
+          return true if eval == -1
+          if eval == 0
+            keep?(current_index, mvalues, vector_order, sort_order, by, vector_order_index + 1)
+          end
+        else # sort in descending order
+          return false if eval == -1
+          return true  if eval == 1
+          if eval == 0
+            keep?(current_index, mvalues, vector_order, sort_order, by, vector_order_index + 1)
+          end
+        end
+      end
+    end
 
-            first_index..last_index
+    def create_logic_blocks vector_order, by={}
+      universal_block = lambda { |a,b| a <=> b }
+      vector_order.each do |vector|
+        by[vector] ||= universal_block
+      end
+
+      by
+    end
+
+    def sort_order_array vector_order, ascending
+      if ascending.is_a?(Array)
+        raise ArgumentError, "Specify same number of vector names and sort orders" if
+          vector_order.size != ascending.size
+        return ascending
+      else
+        Array.new(vector_order.size, ascending)
+      end
+    end
+
+    def vectors_index_for location
+      if @vectors.include?(location)
+        @vectors[location]
+      elsif location[0].is_a?(Integer)
+        location[0]
+      end
+    end
+
+    def access_vector *names
+      location = names[0]
+      if @vectors.is_a?(MultiIndex)
+        pos = vectors_index_for names
+
+        if pos.is_a?(Integer)
+          return @data[pos]
+        else # MultiIndex
+          new_vectors = pos.map do |tuple|
+            @data[vectors_index_for(names + tuple)]
           end
+          Daru::DataFrame.new(new_vectors, index: @index, order: Daru::MultiIndex.new(pos.to_a))
+        end
+      else
+        unless names[1]
+          pos = vectors_index_for location
+          return @data[pos]
+        end
+
+        new_vcs = {}
+        names.each do |name|
+          name = name.to_sym unless name.is_a?(Integer)
+          new_vcs[name] = @data[@vectors[name]]
+        end
+        Daru::DataFrame.new new_vcs, order: new_vcs.keys, index: @index, name: @name
+      end
+    end
+
+    def access_row *names
+      location = names[0]
 
-          names = index_arry[range]
+      if @index.is_a?(MultiIndex)
+        pos = row_index_for names
+        if pos.is_a?(Integer)
+          return Daru::Vector.new(populate_row_for(pos), index: @vectors, name: pos)
         else
-          row  = []
-          name = named_index_for names[0]
-          @vectors.each do |vector|
-            row << @data[@vectors[vector]][name]
+          new_rows =
+          if location.is_a?(Range)
+            pos.map { |tuple| populate_row_for(tuple) }
+          else
+            pos.map { |tuple| populate_row_for(names + tuple) }
           end
+          
+          Daru::DataFrame.rows(new_rows, order: @vectors, name: @name, 
+            index: Daru::MultiIndex.new(pos.to_a))
+        end
+      else
+        if names[1].nil? 
+          if location.is_a?(Range)
+            index_arry = @index.to_a
 
-          return Daru::Vector.new(row, index: @vectors, name: name, dtype: @dtype)
+            range = 
+            if location.first.is_a?(Numeric)
+              location
+            else
+              first_index = index_arry.index location.first
+              last_index  = index_arry.index location.last
+
+              first_index..last_index
+            end
+
+            names = index_arry[range]
+          else
+            row  = []
+            name = named_index_for names[0]
+            @vectors.each do |vector|
+              row << @data[@vectors[vector]][name]
+            end
+
+            return Daru::Vector.new(row, index: @vectors, name: set_name(name))
+          end
         end
+        # Access multiple rows
+        rows = []
+        names.each do |name|
+          rows << self.row[name]
+        end
+        
+        Daru::DataFrame.rows rows, name: @name        
       end
-      # Access multiple rows
-      rows = []
-      names.each do |name|
-        rows << self.row[name]
+    end
+
+    def row_index_for location
+      if @index.include?(location) or location[0].is_a?(Range)
+        @index[location]
+      elsif location[0].is_a?(Integer)
+        location[0]
+      end
+    end
+
+    def populate_row_for pos
+      @vectors.map do |vector|
+        @data[@vectors[vector]][pos]
       end
-      
-      Daru::DataFrame.rows rows, name: @name, dtype: @dtype
     end
 
     def insert_or_modify_vector name, vector
-      @vectors = @vectors.re_index(@vectors + name)
+      @vectors = reassign_index_as(@vectors + name)
       v        = nil
 
       if vector.is_a?(Daru::Vector)
-        v = Daru::Vector.new [], name: name, index: @index, dtype: @dtype
-        nil_data = false
+        v = Daru::Vector.new [], name: set_name(name), index: @index
         @index.each do |idx|
-          begin
-            v[idx] = vector[idx]
-          rescue IndexError
-            v[idx] = nil
-          end
+          v[idx] = vector[idx]
         end
       else
         raise Exception, "Specified vector of length #{vector.size} cannot be inserted in DataFrame of size #{@size}" if
           @size != vector.size
 
-        v = vector.dv(name, @index, @dtype)
+        v = Daru::Vector.new(vector, name: set_name(name), index: @index)
       end
 
       @data[@vectors[name]] = v
@@ -585,25 +1016,17 @@ module Daru
 
     def insert_or_modify_row name, vector      
       if @index.include? name
-        v = vector.dv(name, @vectors, @dtype)
+        v = vector.dv(name, @vectors, @dtype) 
 
         @vectors.each do |vector|
-          begin
-            @data[@vectors[vector]][name] = v[vector] 
-          rescue IndexError
-            @data[@vectors[vector]][name] = nil
-          end
+          @data[@vectors[vector]][name] = v[vector] 
         end
       else
-        @index = @index.re_index(@index + name)
-        v      = vector.dv(name, @vectors, @dtype)
+        @index = reassign_index_as(@index + name)
+        v      = Daru::Vector.new(vector, name: set_name(name), index: @vectors)
 
         @vectors.each do |vector|
-          begin
-            @data[@vectors[vector]].concat v[vector], name     
-          rescue IndexError
-            @data[@vectors[vector]].concat nil, name
-          end
+          @data[@vectors[vector]].concat v[vector], name
         end
       end
 
@@ -612,16 +1035,16 @@ module Daru
 
     def create_empty_vectors
       @vectors.each do |name|
-        @data << Daru::Vector.new([],name: name, index: @index, dtype: @dtype)
+        @data << Daru::Vector.new([], name: set_name(name), index: @index)
       end
     end
 
     def validate_labels
-      raise IndexError, "Expected equal number of vectors for number of Hash pairs" if 
-        @vectors.size != @data.size
+      raise IndexError, "Expected equal number of vector names (#{@vectors.size}) for number of vectors (#{@data.size})." if 
+        @vectors and @vectors.size != @data.size
 
       raise IndexError, "Expected number of indexes same as number of rows" if
-        @index.size != @data[0].size
+        @index and @data[0] and @index.size != @data[0].size
     end
 
     def validate_vector_sizes
@@ -631,8 +1054,6 @@ module Daru
     end
 
     def validate
-      # TODO: [IMP] when vectors of different dimensions are specified, they should
-      # be inserted into the dataframe by inserting nils wherever necessary.
       validate_labels
       validate_vector_sizes
     end
@@ -660,10 +1081,10 @@ module Daru
     def create_vectors_index_with vectors, source
       vectors = source.keys.sort if vectors.nil?
 
-      if vectors.is_a?(Daru::Index)
-        @vectors = vectors.to_index
-      else
+      unless vectors.is_a?(Index) or vectors.is_a?(MultiIndex)
         @vectors = Daru::Index.new (vectors + (source.keys - vectors)).uniq.map(&:to_sym)
+      else
+        @vectors = vectors
       end
     end
 
@@ -674,5 +1095,32 @@ module Daru
         index == vector.index
       end
     end
+
+    def reassign_index_as new_index
+      Daru::Index.new new_index
+    end
+
+    def create_index index
+      index.is_a?(MultiIndex) ? index : Daru::Index.new(index)
+    end
+
+    def set_name potential_name
+      potential_name.is_a?(Array) ? potential_name.join.to_sym : potential_name
+    end
+
+    def symbolize arry
+      symbolized_arry = 
+      if arry.all? { |e| e.is_a?(Array) }
+        arry.map do |sub_arry|
+          sub_arry.map do |e|
+            e.is_a?(Numeric) ? e : e.to_sym
+          end
+        end
+      else
+        arry.map { |e| e.is_a?(Numeric) ? e : e.to_sym }
+      end
+
+      symbolized_arry
+    end
   end
 end