daru_lite 0.1.1 → 0.1.2

data/lib/daru_lite/data_frame/indexable.rb

@@ -0,0 +1,168 @@
+module DaruLite
+  class DataFrame
+    module Indexable
+      module SetSingleIndexStrategy
+        def self.uniq_size(df, col)
+          df[col].uniq.size
+        end
+
+        def self.new_index(df, col)
+          DaruLite::Index.new(df[col].to_a)
+        end
+
+        def self.delete_vector(df, col)
+          df.delete_vector(col)
+        end
+      end
+
+      module SetCategoricalIndexStrategy
+        def self.new_index(df, col)
+          DaruLite::CategoricalIndex.new(df[col].to_a)
+        end
+
+        def self.delete_vector(df, col)
+          df.delete_vector(col)
+        end
+      end
+
+      module SetMultiIndexStrategy
+        def self.uniq_size(df, cols)
+          df[*cols].uniq.size
+        end
+
+        def self.new_index(df, cols)
+          DaruLite::MultiIndex.from_arrays(df[*cols].map_vectors(&:to_a)).tap do |mi|
+            mi.name = cols
+          end
+        end
+
+        def self.delete_vector(df, cols)
+          df.delete_vectors(*cols)
+        end
+      end
+
+      # Set a particular column as the new DF
+      def set_index(new_index_col, keep: false, categorical: false)
+        if categorical
+          strategy = SetCategoricalIndexStrategy
+        elsif new_index_col.respond_to?(:to_a)
+          strategy = SetMultiIndexStrategy
+          new_index_col = new_index_col.to_a
+        else
+          strategy = SetSingleIndexStrategy
+        end
+
+        unless categorical
+          uniq_size = strategy.uniq_size(self, new_index_col)
+          raise ArgumentError, 'All elements in new index must be unique.' if @size != uniq_size
+        end
+
+        self.index = strategy.new_index(self, new_index_col)
+        strategy.delete_vector(self, new_index_col) unless keep
+        self
+      end
+
+      # Change the index of the DataFrame and preserve the labels of the previous
+      # indexing. New index can be DaruLite::Index or any of its subclasses.
+      #
+      # @param [DaruLite::Index] new_index The new Index for reindexing the DataFrame.
+      # @example Reindexing DataFrame
+      #   df = DaruLite::DataFrame.new({a: [1,2,3,4], b: [11,22,33,44]},
+      #     index: ['a','b','c','d'])
+      #   #=>
+      #   ##<DaruLite::DataFrame:83278130 @name = b19277b8-c548-41da-ad9a-2ad8c060e273 @size = 4>
+      #   #                    a          b
+      #   #         a          1         11
+      #   #         b          2         22
+      #   #         c          3         33
+      #   #         d          4         44
+      #   df.reindex DaruLite::Index.new(['b', 0, 'a', 'g'])
+      #   #=>
+      #   ##<DaruLite::DataFrame:83177070 @name = b19277b8-c548-41da-ad9a-2ad8c060e273 @size = 4>
+      #   #                    a          b
+      #   #         b          2         22
+      #   #         0        nil        nil
+      #   #         a          1         11
+      #   #         g        nil        nil
+      def reindex(new_index)
+        unless new_index.is_a?(DaruLite::Index)
+          raise ArgumentError, 'Must pass the new index of type Index or its ' \
+                               "subclasses, not #{new_index.class}"
+        end
+
+        cl = DaruLite::DataFrame.new({}, order: @vectors, index: new_index, name: @name)
+        new_index.each_with_object(cl) do |idx, memo|
+          memo.row[idx] = @index.include?(idx) ? row[idx] : Array.new(ncols)
+        end
+      end
+
+      def reset_index
+        index_df = index.to_df
+        names = index.name
+        names = [names] unless names.instance_of?(Array)
+        new_vectors = names + vectors.to_a
+        self.index = index_df.index
+        names.each do |name|
+          self[name] = index_df[name]
+        end
+        self.order = new_vectors
+        self
+      end
+
+      # Reassign index with a new index of type DaruLite::Index or any of its subclasses.
+      #
+      # @param [DaruLite::Index] idx New index object on which the rows of the dataframe
+      #   are to be indexed.
+      # @example Reassigining index of a DataFrame
+      #   df = DaruLite::DataFrame.new({a: [1,2,3,4], b: [11,22,33,44]})
+      #   df.index.to_a #=> [0,1,2,3]
+      #
+      #   df.index = DaruLite::Index.new(['a','b','c','d'])
+      #   df.index.to_a #=> ['a','b','c','d']
+      #   df.row['a'].to_a #=> [1,11]
+      def index=(idx)
+        @index = Index.coerce idx
+        @data.each { |vec| vec.index = @index }
+
+        self
+      end
+
+      def reindex_vectors(new_vectors)
+        unless new_vectors.is_a?(DaruLite::Index)
+          raise ArgumentError, 'Must pass the new index of type Index or its ' \
+                               "subclasses, not #{new_vectors.class}"
+        end
+
+        cl = DaruLite::DataFrame.new({}, order: new_vectors, index: @index, name: @name)
+        new_vectors.each_with_object(cl) do |vec, memo|
+          memo[vec] = @vectors.include?(vec) ? self[vec] : Array.new(nrows)
+        end
+      end
+
+      # Reassign vectors with a new index of type DaruLite::Index or any of its subclasses.
+      #
+      # @param new_index [DaruLite::Index] idx The new index object on which the vectors are to
+      #   be indexed. Must of the same size as ncols.
+      # @example Reassigning vectors of a DataFrame
+      #   df = DaruLite::DataFrame.new({a: [1,2,3,4], b: [:a,:b,:c,:d], c: [11,22,33,44]})
+      #   df.vectors.to_a #=> [:a, :b, :c]
+      #
+      #   df.vectors = DaruLite::Index.new([:foo, :bar, :baz])
+      #   df.vectors.to_a #=> [:foo, :bar, :baz]
+      def vectors=(new_index)
+        raise ArgumentError, 'Can only reindex with Index and its subclasses' unless new_index.is_a?(DaruLite::Index)
+
+        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
+    end
+  end
+end

data/lib/daru_lite/data_frame/iterable.rb

@@ -0,0 +1,339 @@
+module DaruLite
+  class DataFrame
+    module Iterable
+      # Iterate over each index of the DataFrame.
+      def each_index(&block)
+        return to_enum(:each_index) unless block
+
+        @index.each(&block)
+
+        self
+      end
+
+      # Iterate over each vector
+      def each_vector(&block)
+        return to_enum(:each_vector) unless block
+
+        @data.each(&block)
+
+        self
+      end
+
+      alias each_column each_vector
+
+      # Iterate over each vector alongwith the name of the vector
+      def each_vector_with_index
+        return to_enum(:each_vector_with_index) unless block_given?
+
+        @vectors.each do |vector|
+          yield @data[@vectors[vector]], vector
+        end
+
+        self
+      end
+
+      alias each_column_with_index each_vector_with_index
+
+      # Iterate over each row
+      def each_row
+        return to_enum(:each_row) unless block_given?
+
+        @index.size.times do |pos|
+          yield row_at(pos)
+        end
+
+        self
+      end
+
+      def each_row_with_index
+        return to_enum(:each_row_with_index) unless block_given?
+
+        @index.each do |index|
+          yield access_row(index), index
+        end
+
+        self
+      end
+
+      # Iterate over each row or vector of the DataFrame. Specify axis
+      # by passing :vector or :row as the argument. Default to :vector.
+      #
+      # == Description
+      #
+      # `#each` works exactly like Array#each. The default mode for `each`
+      # is to iterate over the columns of the DataFrame. To iterate over
+      # rows you must pass the axis, i.e `:row` as an argument.
+      #
+      # == Arguments
+      #
+      # * +axis+ - The axis to iterate over. Can be :vector (or :column)
+      # or :row. Default to :vector.
+      def each(axis = :vector, &block)
+        dispatch_to_axis axis, :each, &block
+      end
+
+      # Iterate over a row or vector and return results in a DaruLite::Vector.
+      # Specify axis with :vector or :row. Default to :vector.
+      #
+      # == Description
+      #
+      # The #collect iterator works similar to #map, the only difference
+      # being that it returns a DaruLite::Vector comprising of the results of
+      # each block run. The resultant Vector has the same index as that
+      # of the axis over which collect has iterated. It also accepts the
+      # optional axis argument.
+      #
+      # == Arguments
+      #
+      # * +axis+ - The axis to iterate over. Can be :vector (or :column)
+      # or :row. Default to :vector.
+      def collect(axis = :vector, &block)
+        dispatch_to_axis_pl axis, :collect, &block
+      end
+
+      # Map over each vector or row of the data frame according to
+      # the argument specified. Will return an Array of the resulting
+      # elements. To map over each row/vector and get a DataFrame,
+      # see #recode.
+      #
+      # == Description
+      #
+      # The #map iterator works like Array#map. The value returned by
+      # each run of the block is added to an Array and the Array is
+      # returned. This method also accepts an axis argument, like #each.
+      # The default is :vector.
+      #
+      # == Arguments
+      #
+      # * +axis+ - The axis to map over. Can be :vector (or :column) or :row.
+      # Default to :vector.
+      def map(axis = :vector, &block)
+        dispatch_to_axis_pl axis, :map, &block
+      end
+
+      # Destructive map. Modifies the DataFrame. Each run of the block
+      # must return a DaruLite::Vector. You can specify the axis to map over
+      # as the argument. Default to :vector.
+      #
+      # == Arguments
+      #
+      # * +axis+ - The axis to map over. Can be :vector (or :column) or :row.
+      # Default to :vector.
+      def map!(axis = :vector, &block)
+        if %i[vector column].include?(axis)
+          map_vectors!(&block)
+        elsif axis == :row
+          map_rows!(&block)
+        end
+      end
+
+      # Maps over the DataFrame and returns a DataFrame. Each run of the
+      # block must return a DaruLite::Vector object. You can specify the axis
+      # to map over. Default to :vector.
+      #
+      # == Description
+      #
+      # Recode works similarly to #map, but an important difference between
+      # the two is that recode returns a modified DaruLite::DataFrame instead
+      # of an Array. For this reason, #recode expects that every run of the
+      # block to return a DaruLite::Vector.
+      #
+      # Just like map and each, recode also accepts an optional _axis_ argument.
+      #
+      # == Arguments
+      #
+      # * +axis+ - The axis to map over. Can be :vector (or :column) or :row.
+      # Default to :vector.
+      def recode(axis = :vector, &block)
+        dispatch_to_axis_pl axis, :recode, &block
+      end
+
+      # Replace specified values with given value
+      # @param [Array] old_values values to replace with new value
+      # @param [object] new_value new value to replace with
+      # @return [DaruLite::DataFrame] Data Frame itself with old values replace
+      #   with new value
+      # @example
+      #   df = DaruLite::DataFrame.new({
+      #     a: [1,    2,          3,   nil,        Float::NAN, nil, 1,   7],
+      #     b: [:a,  :b,          nil, Float::NAN, nil,        3,   5,   8],
+      #     c: ['a',  Float::NAN, 3,   4,          3,          5,   nil, 7]
+      #   }, index: 11..18)
+      #   df.replace_values nil, Float::NAN
+      #   # => #<DaruLite::DataFrame(8x3)>
+      #   #       a   b   c
+      #   #   11   1   a   a
+      #   #   12   2   b NaN
+      #   #   13   3 NaN   3
+      #   #   14 NaN NaN   4
+      #   #   15 NaN NaN   3
+      #   #   16 NaN   3   5
+      #   #   17   1   5 NaN
+      #   #   18   7   8   7
+      def replace_values(old_values, new_value)
+        @data.each { |vec| vec.replace_values old_values, new_value }
+        self
+      end
+
+      # Test each row with one or more tests.
+      # @param tests [Proc]  Each test is a Proc with the form
+      #                      *Proc.new {|row| row[:age] > 0}*
+      # The function returns an array with all errors.
+      #
+      # FIXME: description here is too sparse. As far as I can get,
+      # it should tell something about that each test is [descr, fields, block],
+      # and that first value may be column name to output. - zverok, 2016-05-18
+      def verify(*tests)
+        id = tests.first.is_a?(Symbol) ? tests.shift : @vectors.first
+
+        each_row_with_index.map do |row, i|
+          tests.reject { |*_, block| block.call(row) }
+               .map { |test| verify_error_message row, test, id, i }
+        end.flatten
+      end
+
+      def recode_vectors
+        block_given? or return to_enum(:recode_vectors)
+
+        dup.tap do |df|
+          df.each_vector_with_index do |v, i|
+            df[*i] = should_be_vector!(yield(v))
+          end
+        end
+      end
+
+      def recode_rows
+        block_given? or return to_enum(:recode_rows)
+
+        dup.tap do |df|
+          df.each_row_with_index do |r, i|
+            df.row[i] = should_be_vector!(yield(r))
+          end
+        end
+      end
+
+      # Map each vector and return an Array.
+      def map_vectors(&block)
+        return to_enum(:map_vectors) unless block
+
+        @data.map(&block)
+      end
+
+      # Destructive form of #map_vectors
+      def map_vectors!
+        return to_enum(:map_vectors!) unless block_given?
+
+        vectors.dup.each do |n|
+          self[n] = should_be_vector!(yield(self[n]))
+        end
+
+        self
+      end
+
+      # Map vectors alongwith the index.
+      def map_vectors_with_index(&block)
+        return to_enum(:map_vectors_with_index) unless block
+
+        each_vector_with_index.map(&block)
+      end
+
+      # Map each row
+      def map_rows(&block)
+        return to_enum(:map_rows) unless block
+
+        each_row.map(&block)
+      end
+
+      def map_rows_with_index(&block)
+        return to_enum(:map_rows_with_index) unless block
+
+        each_row_with_index.map(&block)
+      end
+
+      def map_rows!
+        return to_enum(:map_rows!) unless block_given?
+
+        index.dup.each do |i|
+          row[i] = should_be_vector!(yield(row[i]))
+        end
+
+        self
+      end
+
+      def apply_method(method, keys: nil, by_position: true)
+        df = keys ? get_sub_dataframe(keys, by_position: by_position) : self
+
+        case method
+        when Symbol then df.send(method)
+        when Proc   then method.call(df)
+        when Array
+          method.map(&:to_proc).map { |proc| proc.call(df) } # works with Array of both Symbol and/or Proc
+        else raise
+        end
+      end
+      alias apply_method_on_sub_df apply_method
+
+      # Retrieves a DaruLite::Vector, based on the result of calculation
+      # performed on each row.
+      def collect_rows(&block)
+        return to_enum(:collect_rows) unless block
+
+        DaruLite::Vector.new(each_row.map(&block), index: @index)
+      end
+
+      def collect_row_with_index(&block)
+        return to_enum(:collect_row_with_index) unless block
+
+        DaruLite::Vector.new(each_row_with_index.map(&block), index: @index)
+      end
+
+      # Retrives a DaruLite::Vector, based on the result of calculation
+      # performed on each vector.
+      def collect_vectors(&block)
+        return to_enum(:collect_vectors) unless block
+
+        DaruLite::Vector.new(each_vector.map(&block), index: @vectors)
+      end
+
+      def collect_vector_with_index(&block)
+        return to_enum(:collect_vector_with_index) unless block
+
+        DaruLite::Vector.new(each_vector_with_index.map(&block), index: @vectors)
+      end
+
+      # Generate a matrix, based on vector names of the DataFrame.
+      #
+      # @return {::Matrix}
+      # :nocov:
+      # FIXME: Even not trying to cover this: I can't get, how it is expected
+      # to work.... -- zverok
+      def collect_matrix
+        return to_enum(:collect_matrix) unless block_given?
+
+        vecs = vectors.to_a
+        rows = vecs.collect do |row|
+          vecs.collect do |col|
+            yield row, col
+          end
+        end
+
+        Matrix.rows(rows)
+      end
+      # :nocov:
+
+      private
+
+      def should_be_vector!(val)
+        return val if val.is_a?(DaruLite::Vector)
+
+        raise TypeError, "Every iteration must return DaruLite::Vector not #{val.class}"
+      end
+
+      def verify_error_message(row, test, id, i)
+        description, fields, = test
+        values = fields.empty? ? '' : " (#{fields.collect { |k| "#{k}=#{row[k]}" }.join(', ')})"
+        "#{i + 1} [#{row[id]}]: #{description}#{values}"
+      end
+    end
+  end
+end

data/lib/daru_lite/data_frame/joinable.rb

@@ -0,0 +1,152 @@
+module DaruLite
+  class DataFrame
+    module Joinable
+      # Concatenate another DataFrame along corresponding columns.
+      # If columns do not exist in both dataframes, they are filled with nils
+      def concat(other_df)
+        vectors = (@vectors.to_a + other_df.vectors.to_a).uniq
+
+        data = vectors.map do |v|
+          get_vector_anyways(v).dup.concat(other_df.get_vector_anyways(v))
+        end
+
+        DaruLite::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 = DaruLite::Index.new(index)
+        df
+      end
+
+      # Merge vectors from two DataFrames. In case of name collision,
+      # the vectors names are changed to x_1, x_2 ....
+      #
+      # @return {DaruLite::DataFrame}
+      def merge(other_df)
+        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)
+        DataFrame.new({}, order: new_fields).tap do |df_new|
+          (0...nrows).each do |i|
+            df_new.add_row row[i].to_a + other_df.row[i].to_a
+          end
+          df_new.index = @index if @index == other_df.index
+          df_new.update
+        end
+      end
+
+      # Join 2 DataFrames with SQL style joins. Currently supports inner, left
+      # outer, right outer and full outer joins.
+      #
+      # @param [DaruLite::DataFrame] other_df Another DataFrame on which the join is
+      #   to be performed.
+      # @param [Hash] opts Options Hash
+      # @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 [DaruLite::DataFrame]
+      # @example Inner Join
+      #   left = DaruLite::DataFrame.new({
+      #     :id   => [1,2,3,4],
+      #     :name => ['Pirate', 'Monkey', 'Ninja', 'Spaghetti']
+      #   })
+      #   right = DaruLite::DataFrame.new({
+      #     :id => [1,2,3,4],
+      #     :name => ['Rutabaga', 'Pirate', 'Darth Vader', 'Ninja']
+      #   })
+      #   left.join(right, how: :inner, on: [:name])
+      #   #=>
+      #   ##<DaruLite::DataFrame:82416700 @name = 74c0811b-76c6-4c42-ac93-e6458e82afb0 @size = 2>
+      #   #                 id_1       name       id_2
+      #   #         0          1     Pirate          2
+      #   #         1          3      Ninja          4
+      def join(other_df, opts = {})
+        DaruLite::Core::Merge.join(self, other_df, opts)
+      end
+
+      # Creates a new dataset for one to many relations
+      # on a dataset, based on pattern of field names.
+      #
+      # for example, you have a survey for number of children
+      # with this structure:
+      #   id, name, child_name_1, child_age_1, child_name_2, child_age_2
+      # with
+      #   ds.one_to_many([:id], "child_%v_%n"
+      # the field of first parameters will be copied verbatim
+      # to new dataset, and fields which responds to second
+      # pattern will be added one case for each different %n.
+      #
+      # @example
+      #   cases=[
+      #     ['1','george','red',10,'blue',20,nil,nil],
+      #     ['2','fred','green',15,'orange',30,'white',20],
+      #     ['3','alfred',nil,nil,nil,nil,nil,nil]
+      #   ]
+      #   ds=DaruLite::DataFrame.rows(cases, order:
+      #     [:id, :name,
+      #      :car_color1, :car_value1,
+      #      :car_color2, :car_value2,
+      #      :car_color3, :car_value3])
+      #   ds.one_to_many([:id],'car_%v%n').to_matrix
+      #   #=> Matrix[
+      #   #   ["red", "1", 10],
+      #   #   ["blue", "1", 20],
+      #   #   ["green", "2", 15],
+      #   #   ["orange", "2", 30],
+      #   #   ["white", "2", 20]
+      #   #   ]
+      def one_to_many(parent_fields, pattern)
+        vars, numbers = one_to_many_components(pattern)
+
+        DataFrame.new([], order: [*parent_fields, '_col_id', *vars]).tap do |ds|
+          each_row do |row|
+            verbatim = parent_fields.map { |f| [f, row[f]] }.to_h
+            numbers.each do |n|
+              generated = one_to_many_row row, n, vars, pattern
+              next if generated.values.all?(&:nil?)
+
+              ds.add_row(verbatim.merge(generated).merge('_col_id' => n))
+            end
+          end
+          ds.update
+        end
+      end
+
+      private
+
+      def one_to_many_components(pattern)
+        re = Regexp.new pattern.gsub('%v', '(.+?)').gsub('%n', '(\\d+?)')
+
+        vars, numbers =
+          @vectors
+          .map { |v| v.scan(re) }
+          .reject(&:empty?).flatten(1).transpose
+
+        [vars.uniq, numbers.map(&:to_i).sort.uniq]
+      end
+
+      def one_to_many_row(row, number, vars, pattern)
+        vars
+          .to_h do |v|
+            name = pattern.sub('%v', v).sub('%n', number.to_s)
+            [v, row[name]]
+          end
+      end
+    end
+  end
+end