daru_lite 0.1.1 → 0.1.2

data/lib/daru_lite/data_frame/fetchable.rb

@@ -0,0 +1,301 @@
+module DaruLite
+  class DataFrame
+    module Fetchable
+      # Access row or vector. Specify name of row/vector followed by axis(:row, :vector).
+      # Defaults to *:vector*. Use of this method is not recommended for accessing
+      # rows. Use df.row[:a] for accessing row with index ':a'.
+      def [](*names)
+        axis = extract_axis(names, :vector)
+        dispatch_to_axis axis, :access, *names
+      end
+
+      # Retrive rows by positions
+      # @param [Array<Integer>] positions of rows to retrive
+      # @return [DaruLite::Vector, DaruLite::DataFrame] vector for single position and dataframe for multiple positions
+      # @example
+      #   df = DaruLite::DataFrame.new({
+      #     a: [1, 2, 3],
+      #     b: ['a', 'b', 'c']
+      #   })
+      #   df.row_at 1, 2
+      #   # => #<DaruLite::DataFrame(2x2)>
+      #   #       a   b
+      #   #   1   2   b
+      #   #   2   3   c
+      def row_at(*positions)
+        original_positions = positions
+        positions = coerce_positions(*positions, nrows)
+        validate_positions(*positions, nrows)
+
+        if positions.is_a? Integer
+          row = get_rows_for([positions])
+          DaruLite::Vector.new(row, index: @vectors, name: @index.at(positions))
+        else
+          new_rows = get_rows_for(original_positions)
+          DaruLite::DataFrame.new(
+            new_rows,
+            index: @index.at(*original_positions),
+            order: @vectors,
+            name: @name
+          )
+        end
+      end
+
+      # Retrive vectors by positions
+      # @param [Array<Integer>] positions of vectors to retrive
+      # @return [DaruLite::Vector, DaruLite::DataFrame] vector for single position and dataframe for multiple positions
+      # @example
+      #   df = DaruLite::DataFrame.new({
+      #     a: [1, 2, 3],
+      #     b: ['a', 'b', 'c']
+      #   })
+      #   df.at 0
+      #   # => #<DaruLite::Vector(3)>
+      #   #       a
+      #   #   0   1
+      #   #   1   2
+      #   #   2   3
+      def at(*positions)
+        if AXES.include? positions.last
+          axis = positions.pop
+          return row_at(*positions) if axis == :row
+        end
+
+        original_positions = positions
+        positions = coerce_positions(*positions, ncols)
+        validate_positions(*positions, ncols)
+
+        if positions.is_a? Integer
+          @data[positions].dup
+        else
+          DaruLite::DataFrame.new positions.map { |pos| @data[pos].dup },
+                                  index: @index,
+                                  order: @vectors.at(*original_positions),
+                                  name: @name
+        end
+      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)
+        row.at 0..(quantity - 1)
+      end
+      alias first head
+
+      # The last ten elements of the DataFrame
+      #
+      # @param [Fixnum] quantity (10) The number of elements to display from the bottom.
+      def tail(quantity = 10)
+        start = [-quantity, -size].max
+        row.at start..-1
+      end
+      alias last tail
+
+      # Extract a dataframe given row indexes or positions
+      # @param keys [Array] can be positions (if by_position is true) or indexes (if by_position if false)
+      # @return [DaruLite::Dataframe]
+      def get_sub_dataframe(keys, by_position: true)
+        return DaruLite::DataFrame.new({}) if keys == []
+
+        keys = @index.pos(*keys) unless by_position
+
+        sub_df = row_at(*keys)
+        sub_df = sub_df.to_df.transpose if sub_df.is_a?(DaruLite::Vector)
+
+        sub_df
+      end
+
+      def get_vector_anyways(v)
+        @vectors.include?(v) ? self[v].to_a : Array.new(size)
+      end
+
+      # @param indexes [Array] index(s) at which row tuples are retrieved
+      # @return [Array] returns array of row tuples at given index(s)
+      # @example Using DaruLite::Index
+      #   df = DaruLite::DataFrame.new({
+      #     a: [1, 2, 3],
+      #     b: ['a', 'a', 'b']
+      #   })
+      #
+      #   df.access_row_tuples_by_indexs(1,2)
+      #   # => [[2, "a"], [3, "b"]]
+      #
+      #   df.index = DaruLite::Index.new([:one,:two,:three])
+      #   df.access_row_tuples_by_indexs(:one,:three)
+      #   # => [[1, "a"], [3, "b"]]
+      #
+      # @example Using DaruLite::MultiIndex
+      #   mi_idx = DaruLite::MultiIndex.from_tuples [
+      #     [:a,:one,:bar],
+      #     [:a,:one,:baz],
+      #     [:b,:two,:bar],
+      #     [:a,:two,:baz],
+      #   ]
+      #   df_mi = DaruLite::DataFrame.new({
+      #     a: 1..4,
+      #     b: 'a'..'d'
+      #   }, index: mi_idx )
+      #
+      #   df_mi.access_row_tuples_by_indexs(:b, :two, :bar)
+      #   # => [[3, "c"]]
+      #   df_mi.access_row_tuples_by_indexs(:a)
+      #   # => [[1, "a"], [2, "b"], [4, "d"]]
+      def access_row_tuples_by_indexs(*indexes)
+        return get_sub_dataframe(indexes, by_position: false).map_rows(&:to_a) if
+        @index.is_a?(DaruLite::MultiIndex)
+
+        positions = @index.pos(*indexes)
+        if positions.is_a? Numeric
+          row = get_rows_for([positions])
+          row.first.is_a?(Array) ? row : [row]
+        else
+          new_rows = get_rows_for(indexes, by_position: false)
+          indexes.map { |index| new_rows.map { |r| r[index] } }
+        end
+      end
+
+      # Split the dataframe into many dataframes based on category vector
+      # @param [object] cat_name name of category vector to split the dataframe
+      # @return [Array] array of dataframes split by category with category vector
+      #   used to split not included
+      # @example
+      #   df = DaruLite::DataFrame.new({
+      #     a: [1, 2, 3],
+      #     b: ['a', 'a', 'b']
+      #   })
+      #   df.to_category :b
+      #   df.split_by_category :b
+      #   # => [#<DaruLite::DataFrame: a (2x1)>
+      #   #       a
+      #   #   0   1
+      #   #   1   2,
+      #   # #<DaruLite::DataFrame: b (1x1)>
+      #   #       a
+      #   #   2   3]
+      def split_by_category(cat_name)
+        cat_dv = self[cat_name]
+        raise ArgumentError, "#{cat_name} is not a category vector" unless
+          cat_dv.category?
+
+        cat_dv.categories.map do |cat|
+          where(cat_dv.eq cat)
+            .rename(cat)
+            .delete_vector cat_name
+        end
+      end
+
+      # Return the indexes of all the numeric vectors. Will include vectors with nils
+      # alongwith numbers.
+      def numeric_vectors
+        # FIXME: Why _with_index ?..
+        each_vector_with_index
+          .select { |vec, _i| vec.numeric? }
+          .map(&:last)
+      end
+
+      def numeric_vector_names
+        @vectors.select { |v| self[v].numeric? }
+      end
+
+      # Return a DataFrame of only the numerical Vectors. If clone: false
+      # is specified as option, only a *view* of the Vectors will be
+      # returned. Defaults to clone: true.
+      def only_numerics(opts = {})
+        cln = opts[:clone] != false
+        arry = numeric_vectors.map { |v| self[v] }
+
+        order = Index.new(numeric_vectors)
+        DaruLite::DataFrame.new(arry, clone: cln, order: order, index: @index)
+      end
+
+      private
+
+      def access_vector(*names)
+        if names.first.is_a?(Range)
+          dup(@vectors.subset(names.first))
+        elsif @vectors.is_a?(MultiIndex)
+          access_vector_multi_index(*names)
+        else
+          access_vector_single_index(*names)
+        end
+      end
+
+      def access_vector_multi_index(*names)
+        pos = @vectors[names]
+
+        return @data[pos] if pos.is_a?(Integer)
+
+        new_vectors = pos.map { |tuple| @data[@vectors[tuple]] }
+
+        pos = pos.drop_left_level(names.size) if names.size < @vectors.width
+
+        DaruLite::DataFrame.new(new_vectors, index: @index, order: pos)
+      end
+
+      def access_vector_single_index(*names)
+        if names.count < 2
+          begin
+            pos = @vectors.is_a?(DaruLite::DateTimeIndex) ? @vectors[names.first] : @vectors.pos(names.first)
+          rescue IndexError
+            raise IndexError, "Specified vector #{names.first} does not exist"
+          end
+          return @data[pos] if pos.is_a?(Numeric)
+
+          names = pos
+        end
+
+        new_vectors = names.map { |name| [name, @data[@vectors.pos(name)]] }.to_h
+
+        order = names.is_a?(Array) ? DaruLite::Index.new(names) : names
+        DaruLite::DataFrame.new(new_vectors, order: order, index: @index, name: @name)
+      end
+
+      def access_row(*indexes)
+        positions = @index.pos(*indexes)
+
+        if positions.is_a? Numeric
+          row = get_rows_for([positions])
+          DaruLite::Vector.new row, index: @vectors, name: indexes.first
+        else
+          new_rows = get_rows_for(indexes, by_position: false)
+          DaruLite::DataFrame.new new_rows, index: @index.subset(*indexes), order: @vectors
+        end
+      end
+
+      # @param keys [Array] can be an array of positions (if by_position is true) or indexes (if by_position if false)
+      # because of coercion by DaruLite::Vector#at and DaruLite::Vector#[], can return either an Array of
+      #   values (representing a row) or an array of Vectors (that can be seen as rows)
+      def get_rows_for(keys, by_position: true)
+        raise unless keys.is_a?(Array)
+
+        if by_position
+          pos = keys
+          @data.map { |vector| vector.at(*pos) }
+        else
+          # TODO: for now (2018-07-27), it is different than using
+          #    get_rows_for(@index.pos(*keys))
+          #    because DaruLite::Vector#at and DaruLite::Vector#[] don't handle DaruLite::MultiIndex the same way
+          indexes = keys
+          @data.map { |vec| vec[*indexes] }
+        end
+      end
+
+      # coerce ranges, integers and array in appropriate ways
+      def coerce_positions(*positions, size)
+        if positions.size == 1
+          case positions.first
+          when Integer
+            positions.first
+          when Range
+            size.times.to_a[positions.first]
+          else
+            raise ArgumentError, 'Unknown position type.'
+          end
+        else
+          positions
+        end
+      end
+    end
+  end
+end

data/lib/daru_lite/data_frame/filterable.rb

@@ -0,0 +1,144 @@
+module DaruLite
+  class DataFrame
+    module Filterable
+      # Return unique rows by vector specified or all vectors
+      #
+      # @param vtrs [String][Symbol] vector names(s) that should be considered
+      #
+      # @example
+      #
+      #    => #<DaruLite::DataFrame(6x2)>
+      #         a   b
+      #     0   1   a
+      #     1   2   b
+      #     2   3   c
+      #     3   4   d
+      #     2   3   c
+      #     3   4   f
+      #
+      #    2.3.3 :> df.uniq
+      #    => #<DaruLite::DataFrame(5x2)>
+      #         a   b
+      #     0   1   a
+      #     1   2   b
+      #     2   3   c
+      #     3   4   d
+      #     3   4   f
+      #
+      #    2.3.3 :> df.uniq(:a)
+      #    => #<DaruLite::DataFrame(5x2)>
+      #         a   b
+      #     0   1   a
+      #     1   2   b
+      #     2   3   c
+      #     3   4   d
+      #
+      def uniq(*vtrs)
+        vecs = vtrs.empty? ? vectors.to_a : Array(vtrs)
+        grouped = group_by(vecs)
+        indexes = grouped.groups.values.map { |v| v[0] }.sort
+        row[*indexes]
+      end
+
+      # Retain vectors or rows if the block returns a truthy value.
+      #
+      # == Description
+      #
+      # For filtering out certain rows/vectors based on their values,
+      # use the #filter method. By default it iterates over vectors and
+      # keeps those vectors for which the block returns true. It accepts
+      # an optional axis argument which lets you specify whether you want
+      # to iterate over vectors or rows.
+      #
+      # == Arguments
+      #
+      # * +axis+ - The axis to map over. Can be :vector (or :column) or :row.
+      # Default to :vector.
+      #
+      # == Usage
+      #
+      #   # Filter vectors
+      #
+      #   df.filter do |vector|
+      #     vector.type == :numeric and vector.median < 50
+      #   end
+      #
+      #   # Filter rows
+      #
+      #   df.filter(:row) do |row|
+      #     row[:a] + row[:d] < 100
+      #   end
+      def filter(axis = :vector, &block)
+        dispatch_to_axis_pl axis, :filter, &block
+      end
+
+      # Returns a dataframe in which rows with any of the mentioned values
+      # are ignored.
+      # @param [Array] values to reject to form the new dataframe
+      # @return [DaruLite::DataFrame] Data Frame with only rows which doesn't
+      #   contain the mentioned values
+      # @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.reject_values nil, Float::NAN
+      #   # => #<DaruLite::DataFrame(2x3)>
+      #   #       a   b   c
+      #   #   11   1   a   a
+      #   #   18   7   8   7
+      def reject_values(*values)
+        positions =
+          size.times.to_a - @data.flat_map { |vec| vec.positions(*values) }
+        # Handle the case when positions size is 1 and #row_at wouldn't return a df
+        if positions.size == 1
+          pos = positions.first
+          row_at(pos..pos)
+        else
+          row_at(*positions)
+        end
+      end
+
+      def keep_row_if
+        @index.size.times
+              .reject { |position| yield(row_at(position)) }
+              .reverse_each { |position| delete_at_position(position) }
+      end
+
+      def keep_vector_if
+        @vectors.each do |vector|
+          delete_vector(vector) unless yield(@data[@vectors[vector]], vector)
+        end
+      end
+
+      # creates a new vector with the data of a given field which the block returns true
+      def filter_vector(vec, &block)
+        DaruLite::Vector.new(each_row.select(&block).map { |row| row[vec] })
+      end
+
+      # Iterates over each row and retains it in a new DataFrame if the block returns
+      # true for that row.
+      def filter_rows
+        return to_enum(:filter_rows) unless block_given?
+
+        keep_rows = @index.map { |index| yield access_row(index) }
+
+        where keep_rows
+      end
+
+      # 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
+
+        dup.tap { |df| df.keep_vector_if(&block) }
+      end
+
+      # Query a DataFrame by passing a DaruLite::Core::Query::BoolArray object.
+      def where(bool_array)
+        DaruLite::Core::Query.df_where self, bool_array
+      end
+    end
+  end
+end

data/lib/daru_lite/data_frame/i_o_able.rb

@@ -0,0 +1,179 @@
+module DaruLite
+  class DataFrame
+    module IOAble
+      module ClassMethods
+        # Load data from a CSV file. Specify an optional block to grab the CSV
+        # object and pre-condition it (for example use the `convert` or
+        # `header_convert` methods).
+        #
+        # == Arguments
+        #
+        # * path - Local path / Remote URL of the file to load specified as a String.
+        #
+        # == Options
+        #
+        # Accepts the same options as the DaruLite::DataFrame constructor and CSV.open()
+        # and uses those to eventually construct the resulting DataFrame.
+        #
+        # == Verbose Description
+        #
+        # You can specify all the options to the `.from_csv` function that you
+        # do to the Ruby `CSV.read()` function, since this is what is used internally.
+        #
+        # For example, if the columns in your CSV file are separated by something
+        # other that commas, you can use the `:col_sep` option. If you want to
+        # convert numeric values to numbers and not keep them as strings, you can
+        # use the `:converters` option and set it to `:numeric`.
+        #
+        # The `.from_csv` function uses the following defaults for reading CSV files
+        # (that are passed into the `CSV.read()` function):
+        #
+        #   {
+        #     :col_sep           => ',',
+        #     :converters        => :numeric
+        #   }
+        def from_csv(path, opts = {}, &block)
+          DaruLite::IO.from_csv path, opts, &block
+        end
+
+        # Read data from an Excel file into a DataFrame.
+        #
+        # == Arguments
+        #
+        # * path - Path of the file to be read.
+        #
+        # == Options
+        #
+        # *:worksheet_id - ID of the worksheet that is to be read.
+        def from_excel(path, opts = {}, &block)
+          DaruLite::IO.from_excel path, opts, &block
+        end
+
+        # Read a database query and returns a Dataset
+        #
+        # @param dbh [DBI::DatabaseHandle, String] A DBI connection OR Path to a SQlite3 database.
+        # @param query [String] The query to be executed
+        #
+        # @return A dataframe containing the data resulting from the query
+        #
+        # USE:
+        #
+        #  dbh = DBI.connect("DBI:Mysql:database:localhost", "user", "password")
+        #  DaruLite::DataFrame.from_sql(dbh, "SELECT * FROM test")
+        #
+        #  #Alternatively
+        #
+        #  require 'dbi'
+        #  DaruLite::DataFrame.from_sql("path/to/sqlite.db", "SELECT * FROM test")
+        def from_sql(dbh, query)
+          DaruLite::IO.from_sql dbh, query
+        end
+
+        # Read a dataframe from AR::Relation
+        #
+        # @param relation [ActiveRecord::Relation] An AR::Relation object from which data is loaded
+        # @param fields [Array] Field names to be loaded (optional)
+        #
+        # @return A dataframe containing the data loaded from the relation
+        #
+        # USE:
+        #
+        #   # When Post model is defined as:
+        #   class Post < ActiveRecord::Base
+        #     scope :active, -> { where.not(published_at: nil) }
+        #   end
+        #
+        #   # You can load active posts into a dataframe by:
+        #   DaruLite::DataFrame.from_activerecord(Post.active, :title, :published_at)
+        def from_activerecord(relation, *fields)
+          DaruLite::IO.from_activerecord relation, *fields
+        end
+
+        # Read the database from a plaintext file. For this method to work,
+        # the data should be present in a plain text file in columns. See
+        # spec/fixtures/bank2.dat for an example.
+        #
+        # == Arguments
+        #
+        # * path - Path of the file to be read.
+        # * fields - Vector names of the resulting database.
+        #
+        # == Usage
+        #
+        #   df = DaruLite::DataFrame.from_plaintext 'spec/fixtures/bank2.dat', [:v1,:v2,:v3,:v4,:v5,:v6]
+        def from_plaintext(path, fields)
+          DaruLite::IO.from_plaintext path, fields
+        end
+
+        def _load(data)
+          h = Marshal.load data
+          DaruLite::DataFrame.new(
+            h[:data],
+            index: h[:index],
+            order: h[:order],
+            name: h[:name]
+          )
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Write this DataFrame to a CSV file.
+      #
+      # == Arguments
+      #
+      # * filename - Path of CSV file where the DataFrame is to be saved.
+      #
+      # == Options
+      #
+      # * convert_comma - If set to *true*, will convert any commas in any
+      # of the data to full stops ('.').
+      # All the options accepted by CSV.read() can also be passed into this
+      # function.
+      def write_csv(filename, opts = {})
+        DaruLite::IO.dataframe_write_csv self, filename, opts
+      end
+
+      # Write this dataframe to an Excel Spreadsheet
+      #
+      # == Arguments
+      #
+      # * filename - The path of the file where the DataFrame should be written.
+      def write_excel(filename, opts = {})
+        DaruLite::IO.dataframe_write_excel self, filename, opts
+      end
+
+      # Insert each case of the Dataset on the selected table
+      #
+      # == Arguments
+      #
+      # * dbh - DBI database connection object.
+      # * query - Query string.
+      #
+      # == Usage
+      #
+      #  ds = DaruLite::DataFrame.new({:id=>DaruLite::Vector.new([1,2,3]), :name=>DaruLite::Vector.new(["a","b","c"])})
+      #  dbh = DBI.connect("DBI:Mysql:database:localhost", "user", "password")
+      #  ds.write_sql(dbh,"test")
+      def write_sql(dbh, table)
+        DaruLite::IO.dataframe_write_sql self, dbh, table
+      end
+
+      # Use marshalling to save dataframe to a file.
+      def save(filename)
+        DaruLite::IO.save self, filename
+      end
+
+      def _dump(_depth)
+        Marshal.dump(
+          data: @data,
+          index: @index.to_a,
+          order: @vectors.to_a,
+          name: @name
+        )
+      end
+    end
+  end
+end