daru 0.1.4.1 → 0.1.5

data/lib/daru/category.rb

@@ -3,9 +3,6 @@ module Daru
     attr_accessor :base_category
     attr_reader :index, :coding_scheme, :name
 
-    # For debuggin. To be removed
-    attr_reader :array, :cat_hash, :map_int_cat
-
     # Initializes a vector to store categorical data.
     # @note Base category is set to the first category encountered in the vector.
     # @param [Array] data the categorical data
@@ -64,11 +61,13 @@ module Daru
       case lib
       when :gruff, :nyaplot
         @plotting_library = lib
-        extend Module.const_get(
-          "Daru::Plotting::Category::#{lib.to_s.capitalize}Library"
-        ) if Daru.send("has_#{lib}?".to_sym)
+        if Daru.send("has_#{lib}?".to_sym)
+          extend Module.const_get(
+            "Daru::Plotting::Category::#{lib.to_s.capitalize}Library"
+          )
+        end
       else
-        raise ArguementError, "Plotting library #{lib} not supported. "\
+        raise ArgumentError, "Plotting library #{lib} not supported. "\
           'Supported libraries are :nyaplot and :gruff'
       end
     end
@@ -160,6 +159,9 @@ module Daru
           counts.map { |c| c / size.to_f }
         when :percentage
           counts.map { |c| c / size.to_f * 100 }
+        else
+          raise ArgumentError, 'Type should be either :count, :fraction or'\
+          " :percentage. #{type} not supported."
         end
       Daru::Vector.new values, index: categories, name: name
     end
@@ -463,12 +465,13 @@ module Daru
 
     # Contrast code the vector acording to the coding scheme set.
     # @note To set the coding scheme use #coding_scheme=
-    # @param [true, false] full true if you want k variables for k categories,
-    #   false if you want k-1 variables for k categories
+    # @param [Hash] opts The options to pass for coding.
+    # @option opts [TrueClass, FalseClass] :full (false) True if you want k variables
+    #   for k categories, false if you want k-1 variables for k categories.
     # @return [Daru::DataFrame] dataframe containing all coded variables
     # @example
     #   dv = Daru::Vector.new [:a, 1, :a, 1, :c], type: :category
-    #   dv.contrast_code
+    #   dv.contrast_code full: false
     #   # => #<Daru::DataFrame(5x2)>
     #   #         daru_1 daru_c
     #   #       0      0      0
@@ -771,9 +774,10 @@ module Daru
 
     def assert_ordered operation
       # TODO: Change ArgumentError to something more expressive
+      return if ordered?
+
       raise ArgumentError, "Can not apply #{operation} when vector is unordered. "\
         'To make the categorical data ordered, use #ordered = true'\
-        unless ordered?
     end
 
     def dummy_coding full
@@ -896,14 +900,17 @@ module Daru
 
     def validate_index index
       # Change to SizeError
+      return unless size != index.size
+
       raise ArgumentError, "Size of index (#{index.size}) does not matches"\
-        "size of vector (#{size})" if size != index.size
+        "size of vector (#{size})"
     end
 
     def modify_category_at pos, category
-      raise ArgumentError, "Invalid category #{category}, "\
-        'to add a new category use #add_category' unless
-        categories.include? category
+      unless categories.include? category
+        raise ArgumentError, "Invalid category #{category}, "\
+          'to add a new category use #add_category'
+      end
       old_category = category_from_position pos
       @array[pos] = int_from_cat category
       @cat_hash[old_category].delete pos

data/lib/daru/core/group_by.rb

@@ -25,6 +25,13 @@ module Daru
         @context = context
         vectors = names.map { |vec| context[vec].to_a }
         tuples  = vectors[0].zip(*vectors[1..-1])
+        # FIXME: It feels like we don't want to sort here. Ruby's #group_by
+        # never sorts:
+        #
+        #   ['test', 'me', 'please'].group_by(&:size)
+        #   #  => {4=>["test"], 2=>["me"], 6=>["please"]}
+        #
+        # - zverok, 2016-09-12
         keys    = tuples.uniq.sort(&TUPLE_SORTER)
 
         keys.each do |key|
@@ -295,12 +302,16 @@ module Daru
             indexes << index
           end
         end
-        indexes
+        if indexes.count == 1
+          [@context.index.at(*indexes)]
+        else
+          @context.index.at(*indexes).to_a
+        end
       end
 
       def multi_indexed_grouping?
         return false unless @groups.keys[0]
-        @groups.keys[0].size > 1 ? true : false
+        @groups.keys[0].size > 1
       end
     end
   end

data/lib/daru/core/merge.rb

@@ -18,11 +18,8 @@ module Daru
       end
 
       def initialize left_df, right_df, opts={}
-        @on = opts[:on]
-        @keep_left, @keep_right = extract_left_right(opts[:how])
-
+        init_opts(opts)
         validate_on!(left_df, right_df)
-
         key_sanitizer = ->(h) { sanitize_merge_keys(h.values_at(*on)) }
 
         @left = df_to_a(left_df)
@@ -46,12 +43,12 @@ module Daru
           row(lkey, rkey).tap { |r| res << r if r }
         end
 
-        Daru::DataFrame.new(res, order: left_keys.values + on + right_keys.values)
+        Daru::DataFrame.new(res, order: dataframe_vector_names)
       end
 
       private
 
-      attr_reader :on,
+      attr_reader :on, :indicator,
         :left, :left_key_values, :keep_left, :left_keys,
         :right, :right_key_values, :keep_right, :right_keys
 
@@ -65,13 +62,23 @@ module Daru
         outer: [true, true]
       }.freeze
 
+      def init_opts(opts)
+        @on = opts[:on]
+        @keep_left, @keep_right = extract_left_right(opts[:how])
+        @indicator = opts[:indicator]
+      end
+
+      def dataframe_vector_names
+        left_keys.values + on + right_keys.values + Array(indicator)
+      end
+
       def extract_left_right(how)
         LEFT_RIGHT_COMBINATIONS[how] or
           raise ArgumentError, "Unrecognized join option: #{how}"
       end
 
       def sanitize_merge_keys(merge_keys)
-        merge_keys.map { |v| v || NilSorter.new }
+        merge_keys.map { |v| v.nil? ? NilSorter.new : v }
       end
 
       def df_to_a df
@@ -110,19 +117,27 @@ module Daru
           # :nocov:
         when lkey == rkey
           self.merge_key = lkey
-          merge_matching_rows
+          add_indicator(merge_matching_rows, :both)
         when !rkey || lt(lkey, rkey)
-          left_row_missing_right
+          add_indicator(left_row_missing_right, :left_only)
         else # !lkey || lt(rkey, lkey)
-          right_row_missing_left
+          add_indicator(right_row_missing_left, :right_only)
         end
       end
 
+      def add_indicator(row, indicator_value)
+        return row unless indicator
+        row[indicator] = indicator_value
+        row
+      end
+
       def merge_matching_rows
         if one_to_one_merge?
           merge_rows(one_to_one_left_row, one_to_one_right_row)
         elsif one_to_many_merge?
-          merge_rows(one_to_many_left_row, one_to_many_right_row)
+          result = merge_rows(left.first, right.first)
+          one_to_many_shift
+          result
         else
           result = cartesian_product.shift
           end_cartesian_product if cartesian_product.empty?
@@ -130,6 +145,13 @@ module Daru
         end
       end
 
+      def one_to_many_shift
+        shift_left = first_right_key != next_right_key
+        shift_right = first_left_key != next_left_key
+        one_to_one_left_row if shift_left
+        one_to_one_right_row if shift_right
+      end
+
       def one_to_one_merge?
         merge_key != next_left_key && merge_key != next_right_key
       end
@@ -143,29 +165,11 @@ module Daru
         left.shift
       end
 
-      def one_to_many_left_row
-        if next_right_key && first_right_key == next_right_key
-          left.first
-        else
-          left_key_values.shift
-          left.shift
-        end
-      end
-
       def one_to_one_right_row
         right_key_values.shift
         right.shift
       end
 
-      def one_to_many_right_row
-        if next_left_key && first_left_key == next_left_key
-          right.first
-        else
-          right_key_values.shift
-          right.shift
-        end
-      end
-
       def left_row_missing_right
         val = one_to_one_left_row
         expand_row(val, left_keys) if keep_left
@@ -184,6 +188,7 @@ module Daru
         left_keys
           .map { |from, to| [to, lrow[from]] }.to_h
           .merge(on.map { |col| [col, lrow[col]] }.to_h)
+          .merge(indicator ? {indicator => nil} : {})
           .merge(right_keys.map { |from, to| [to, rrow[from]] }.to_h)
       end
 
@@ -191,6 +196,7 @@ module Daru
         renamings
           .map { |from, to| [to, row[from]] }.to_h
           .merge(on.map { |col| [col, row[col]] }.to_h)
+          .merge(indicator ? {indicator => nil} : {})
       end
 
       def first_right_key
@@ -198,7 +204,7 @@ module Daru
       end
 
       def next_right_key
-        right_key_values.size <= 1 ? nil : right_key_values[1]
+        right_key_values[1]
       end
 
       def first_left_key
@@ -206,7 +212,7 @@ module Daru
       end
 
       def next_left_key
-        left_key_values.size <= 1 ? nil : left_key_values[1]
+        left_key_values[1]
       end
 
       def left_rows_at_merge_key

data/lib/daru/core/query.rb

@@ -75,8 +75,16 @@ module Daru
         def fetch_new_data_and_index dv, bool_array
           barry = bool_array.to_a
           positions = dv.size.times.select { |i| barry[i] }
-          new_data = dv.to_a.values_at(*positions)
-          new_index = dv.index.to_a.values_at(*positions)
+          # FIXME: The below 4 lines should be replaced with values_at when the
+          # stack error is fixed in Ruby.
+          # eg - new_data = dv.data.data.values_at(*positions)
+
+          data = dv.type == :category ? dv.to_a : dv.data.data # non-cat optimize
+          new_data = positions.map { |i| data[i] }
+
+          idx = dv.index.to_a
+          new_index = positions.map { |i| idx[i] }
+
           [new_data, new_index]
         end
       end

data/lib/daru/dataframe.rb

@@ -120,7 +120,7 @@ module Daru
 
         opts[:order] ||= guess_order(source)
 
-        if ArrayHelper.array_of?(source, Array)
+        if ArrayHelper.array_of?(source, Array) || source.empty?
           DataFrame.new(source.transpose, opts)
         elsif ArrayHelper.array_of?(source, Vector)
           from_vector_rows(source, opts)
@@ -265,9 +265,11 @@ module Daru
       case lib
       when :gruff, :nyaplot
         @plotting_library = lib
-        extend Module.const_get(
-          "Daru::Plotting::DataFrame::#{lib.to_s.capitalize}Library"
-        ) if Daru.send("has_#{lib}?".to_sym)
+        if Daru.send("has_#{lib}?".to_sym)
+          extend Module.const_get(
+            "Daru::Plotting::DataFrame::#{lib.to_s.capitalize}Library"
+          )
+        end
       else
         raise ArguementError, "Plotting library #{lib} not supported. "\
           'Supported libraries are :nyaplot and :gruff'
@@ -974,6 +976,26 @@ module Daru
       Daru::Vector.new a, index: @index
     end
 
+    # Reorder the vectors in a dataframe
+    # @param [Array] order_array new order of the vectors
+    # @example
+    #   df = Daru::DataFrame({
+    #     a: [1, 2, 3],
+    #     b: [4, 5, 6]
+    #   }, order: [:a, :b])
+    #   df.order = [:b, :a]
+    #   df
+    #   # => #<Daru::DataFrame(3x2)>
+    #   #       b   a
+    #   #   0   4   1
+    #   #   1   5   2
+    #   #   2   6   3
+    def order=(order_array)
+      raise ArgumentError, 'Invalid order' unless
+        order_array.sort == vectors.to_a.sort
+      initialize(to_h, order: order_array)
+    end
+
     # Returns a vector, based on a string with a calculation based
     # on vector.
     #
@@ -1103,7 +1125,7 @@ module Daru
         each_row do |row|
           return true if yield(row)
         end
-        return false
+        false
       else
         raise ArgumentError, "Unidentified axis #{axis}"
       end
@@ -1204,12 +1226,16 @@ module Daru
         raise(ArgumentError, "Vector #{v} does not exist") unless has_vector?(v)
       }
 
+      vectors = [@vectors.first] if vectors.empty?
+
       Daru::Core::GroupBy.new(self, vectors)
     end
 
     def reindex_vectors new_vectors
-      raise ArgumentError, 'Must pass the new index of type Index or its '\
-        "subclasses, not #{new_index.class}" unless new_vectors.is_a?(Daru::Index)
+      unless new_vectors.is_a?(Daru::Index)
+        raise ArgumentError, 'Must pass the new index of type Index or its '\
+          "subclasses, not #{new_index.class}"
+      end
 
       cl = Daru::DataFrame.new({}, order: new_vectors, index: @index, name: @name)
       new_vectors.each_with_object(cl) do |vec, memo|
@@ -1233,6 +1259,19 @@ module Daru
       Daru::DataFrame.new(data, order: vectors)
     end
 
+    # Concatenates another DataFrame as #concat.
+    # Additionally it tries to preserve the index. If the indices contain
+    # common elements, #union will overwrite the according rows in the
+    # first dataframe.
+    def union other_df
+      index = (@index.to_a + other_df.index.to_a).uniq
+      df = row[*(@index.to_a - other_df.index.to_a)]
+
+      df = df.concat(other_df)
+      df.index = Daru::Index.new(index)
+      df
+    end
+
     # Set a particular column as the new DF
     def set_index new_index, opts={}
       raise ArgumentError, 'All elements in new index must be unique.' if
@@ -1267,8 +1306,10 @@ module Daru
     #   #         a          1         11
     #   #         g        nil        nil
     def reindex new_index
-      raise ArgumentError, 'Must pass the new index of type Index or its '\
-        "subclasses, not #{new_index.class}" unless new_index.is_a?(Daru::Index)
+      unless new_index.is_a?(Daru::Index)
+        raise ArgumentError, 'Must pass the new index of type Index or its '\
+          "subclasses, not #{new_index.class}"
+      end
 
       cl = Daru::DataFrame.new({}, order: @vectors, index: new_index, name: @name)
       new_index.each_with_object(cl) do |idx, memo|
@@ -1304,13 +1345,20 @@ module Daru
     #
     #   df.vectors = Daru::Index.new([:foo, :bar, :baz])
     #   df.vectors.to_a #=> [:foo, :bar, :baz]
-    def vectors= idx
-      raise ArgumentError, 'Can only reindex with Index and its subclasses' unless
-        index.is_a?(Daru::Index)
-      raise ArgumentError, "Specified index length #{idx.size} not equal to"\
-        "dataframe size #{ncols}" if idx.size != ncols
+    def vectors= new_index
+      unless new_index.is_a?(Daru::Index)
+        raise ArgumentError, 'Can only reindex with Index and its subclasses'
+      end
 
-      @vectors = idx
+      if new_index.size != ncols
+        raise ArgumentError, "Specified index length #{new_index.size} not equal to"\
+          "dataframe size #{ncols}"
+      end
+
+      @vectors = new_index
+      @data.zip(new_index.to_a).each do |vect, name|
+        vect.name = name
+      end
       self
     end
 
@@ -1521,7 +1569,7 @@ module Daru
     #   #     [:bar]         18         26
     #   #     [:foo]         10         12
     def pivot_table opts={}
-      raise ArgumentError, 'Specify grouping index' if opts[:index].to_a.empty?
+      raise ArgumentError, 'Specify grouping index' if Array(opts[:index]).empty?
 
       index               = opts[:index]
       vectors             = opts[:vectors] || []
@@ -1542,9 +1590,10 @@ module Daru
     #
     # @return {Daru::DataFrame}
     def merge other_df # rubocop:disable Metrics/AbcSize
-      raise ArgumentError,
-        "Number of rows must be equal in this: #{nrows} and other: #{other_df.nrows}" \
-        unless nrows == other_df.nrows
+      unless nrows == other_df.nrows
+        raise ArgumentError,
+          "Number of rows must be equal in this: #{nrows} and other: #{other_df.nrows}"
+      end
 
       new_fields = (@vectors.to_a + other_df.vectors.to_a)
       new_fields = ArrayHelper.recode_repeated(new_fields)
@@ -1567,6 +1616,9 @@ module Daru
     # @option :how [Symbol] Can be one of :inner, :left, :right or :outer.
     # @option :on [Array] The columns on which the join is to be performed.
     #   Column names specified here must be common to both DataFrames.
+    # @option :indicator [Symbol] The name of a vector to add to the resultant
+    #   dataframe that indicates whether the record was in the left (:left_only),
+    #   right (:right_only), or both (:both) joining dataframes.
     # @return [Daru::DataFrame]
     # @example Inner Join
     #   left = Daru::DataFrame.new({
@@ -1892,10 +1944,15 @@ module Daru
     end
 
     def method_missing(name, *args, &block)
-      if name =~ /(.+)\=/
-        insert_or_modify_vector [name[/(.+)\=/].delete('=').to_sym], args[0]
-      elsif has_vector? name
+      case
+      when name =~ /(.+)\=/
+        name = name[/(.+)\=/].delete('=')
+        name = name.to_sym unless has_vector?(name)
+        insert_or_modify_vector [name], args[0]
+      when has_vector?(name)
         self[name]
+      when has_vector?(name.to_s)
+        self[name.to_s]
       else
         super
       end
@@ -2060,7 +2117,7 @@ module Daru
     end
 
     def populate_row_for pos
-      @data.map { |vector| vector[pos] }
+      @data.map { |vector| vector.at(*pos) }
     end
 
     def insert_or_modify_vector name, vector
@@ -2128,9 +2185,10 @@ module Daru
         }
       else
         # FIXME: No spec checks this case... And SizeError is not a thing - zverok, 2016-05-08
-        raise SizeError,
-          "Specified vector of length #{vector.size} cannot be inserted in DataFrame of size #{@size}" if
-          @size != vector.size
+        if @size != vector.size
+          raise SizeError,
+            "Specified vector of length #{vector.size} cannot be inserted in DataFrame of size #{@size}"
+        end
 
         Daru::Vector.new(vector, name: coerce_name(name), index: @index)
       end
@@ -2157,12 +2215,13 @@ module Daru
     end
 
     def validate_labels
-      raise IndexError, "Expected equal number of vector names (#{@vectors.size}) " \
-        "for number of vectors (#{@data.size})." if
-        @vectors && @vectors.size != @data.size
+      if @vectors && @vectors.size != @data.size
+        raise IndexError, "Expected equal number of vector names (#{@vectors.size}) " \
+          "for number of vectors (#{@data.size})."
+      end
 
-      raise IndexError, 'Expected number of indexes same as number of rows' if
-        @index && @data[0] && @index.size != @data[0].size
+      return unless @index && @data[0] && @index.size != @data[0].size
+      raise IndexError, 'Expected number of indexes same as number of rows'
     end
 
     def validate_vector_sizes
@@ -2228,8 +2287,10 @@ module Daru
     end
 
     def initialize_from_array_of_arrays source, vectors, index, _opts
-      raise ArgumentError, "Number of vectors (#{vectors.size}) should \
-        equal order size (#{source.size})" if source.size != vectors.size
+      if source.size != vectors.size
+        raise ArgumentError, "Number of vectors (#{vectors.size}) should " \
+          "equal order size (#{source.size})"
+      end
 
       @index   = Index.coerce(index || source[0].size)
       @vectors = Index.coerce(vectors)
@@ -2258,7 +2319,7 @@ module Daru
       @index = Daru::Index.new(index || source.size)
 
       @data = @vectors.map do |name|
-        v = source.map { |h| h[name] || h[name.to_s] }
+        v = source.map { |h| h.fetch(name) { h[name.to_s] } }
         Daru::Vector.new(v, name: coerce_name(name), index: @index)
       end
     end