charty 0.2.0 → 0.2.6

data/lib/charty/table_adapters/base_adapter.rb

@@ -0,0 +1,166 @@
+require "forwardable"
+
+module Charty
+  module TableAdapters
+    class BaseAdapter
+      extend Forwardable
+      include Enumerable
+
+      attr_reader :columns
+
+      def columns=(values)
+        @columns = check_and_convert_index(values, :columns, column_length)
+      end
+
+      def column_names
+        columns.to_a
+      end
+
+      attr_reader :index
+
+      def index=(values)
+        @index = check_and_convert_index(values, :index, length)
+      end
+
+      def ==(other)
+        case other
+        when BaseAdapter
+          return false if columns != other.columns
+          return false if index != other.index
+          compare_data_equality(other)
+        else
+          false
+        end
+      end
+
+      def group_by(table, grouper, sort, drop_na)
+        Table::HashGroupBy.new(table, grouper, sort, drop_na)
+      end
+
+      def compare_data_equality(other)
+        columns.each do |name|
+          if self[nil, name] != other[nil, name]
+            return false
+          end
+        end
+        true
+      end
+
+      def drop_na
+        # TODO: Must implement this method in each adapter
+        missing_index = index.select do |i|
+          column_names.any? do |key|
+            Util.missing?(self[i, key])
+          end
+        end
+        if missing_index.empty?
+          nil
+        else
+          select_index = index.to_a - missing_index
+          new_data = column_names.map { |key|
+            vals = select_index.map {|i| self[i, key] }
+            [key, vals]
+          }.to_h
+          Charty::Table.new(new_data, index: select_index)
+        end
+      end
+
+      def sort_values(by, na_position: :last)
+        na_cmp_val = check_na_position(na_position)
+        case by
+        when String, Symbol
+          order = (0 ... length).sort do |i, j|
+            a = self[i, by]
+            b = self[j, by]
+            case
+            when Util.missing?(a)  # missing > b
+              na_cmp_val
+            when Util.missing?(b)  # a < missing
+              -na_cmp_val
+            else
+              cmp = a <=> b
+              if cmp == 0
+                i <=> j
+              else
+                cmp
+              end
+            end
+          end
+        when Array
+          order = (0 ... length).sort do |i, j|
+            cmp = 0
+            by.each do |key|
+              a = self[i, key]
+              b = self[j, key]
+              case
+              when Util.missing?(a)  # missing > b
+                cmp = na_cmp_val
+                break
+              when Util.missing?(b)  # a < missing
+                cmp = -na_cmp_val
+                break
+              else
+                cmp = a <=> b
+                break if cmp != 0
+              end
+            end
+            if cmp == 0
+              i <=> j
+            else
+              cmp
+            end
+          end
+        else
+          raise ArgumentError,
+                "%p is invalid value for `by`" % by
+        end
+
+        Charty::Table.new(
+          column_names.map { |name|
+            [
+              name,
+              self[nil, name].values_at(*order)
+            ]
+          }.to_h,
+          index: index.to_a.values_at(*order)
+        )
+      end
+
+      private def check_na_position(val)
+        case val
+        when :first, "first"
+          -1
+        when :last, "last"
+          1
+        else
+          raise ArgumentError,
+                "`na_position` must be :first or :last",
+                caller
+        end
+      end
+
+      private def check_and_convert_index(values, name, expected_length)
+        case values
+        when Index, Range
+        else
+          unless (ary = Array.try_convert(values))
+            raise ArgumentError, "invalid object for %s: %p" % [name, values]
+          end
+          values = ary
+        end
+        if expected_length != values.size
+          raise ArgumentError,
+                "invalid length for %s (%d for %d)" % [name, values.size, expected_length]
+        end
+        case values
+        when Index
+          values
+        when Range
+          RangeIndex.new(values)
+        when Array
+          Index.new(values)
+        end
+      end
+    end
+  end
+end

data/lib/charty/table_adapters/daru_adapter.rb

@@ -1,27 +1,65 @@
+require "delegate"
+
 module Charty
   module TableAdapters
-    class DaruAdapter
+    class DaruAdapter < BaseAdapter
       TableAdapters.register(:daru, self)
 
+      extend Forwardable
       include Enumerable
 
       def self.supported?(data)
         defined?(Daru::DataFrame) && data.is_a?(Daru::DataFrame)
       end
 
-      def initialize(data)
+      def initialize(data, columns: nil, index: nil)
         @data = check_type(Daru::DataFrame, data, :data)
+
+        self.columns = columns unless columns.nil?
+        self.index = index unless index.nil?
+      end
+
+      attr_reader :data
+
+      def_delegator :data, :size, :length
+
+      def index
+        DaruIndex.new(data.index)
+      end
+
+      def_delegator :data, :index=
+
+      def columns
+        DaruIndex.new(data.vectors)
+      end
+
+      def columns=(values)
+        data.vectors = Daru::Index.coerce(values)
       end
 
       def column_names
         @data.vectors.to_a
       end
 
+      def compare_data_equality(other)
+        case other
+        when DaruAdapter
+          data == other.data
+        else
+          super
+        end
+      end
+
       def [](row, column)
         if row
           @data[column][row]
         else
-          @data[column]
+          column_data = if @data.has_vector?(column)
+                          @data[column]
+                        else
+                          @data[column.to_s]
+                        end
+          Vector.new(column_data)
         end
       end
 

data/lib/charty/table_adapters/datasets_adapter.rb

@@ -1,6 +1,6 @@
 module Charty
   module TableAdapters
-    class DatasetsAdapter
+    class DatasetsAdapter < BaseAdapter
       TableAdapters.register(:datasets, self)
 
       include Enumerable
@@ -13,12 +13,27 @@ module Charty
       def initialize(dataset)
         @table = dataset.to_table
         @records = []
+
+        self.columns = self.column_names
+        self.index = 0 ... length
+      end
+
+      def data
+        @table
+      end
+
+      def column_length
+        column_names.length
       end
 
       def column_names
         @table.column_names
       end
 
+      def length
+        data.n_rows
+      end
+
       def each(&block)
         return to_enum(__method__) unless block_given?
 
@@ -33,7 +48,7 @@ module Charty
           return nil if record.nil?
           record[column]
         else
-          @table[column]
+          Vector.new(@table[column], index: index, name: column)
         end
       end
     end

data/lib/charty/table_adapters/hash_adapter.rb

@@ -1,14 +1,10 @@
 require 'date'
-require 'forwardable'
 
 module Charty
   module TableAdapters
-    class HashAdapter
+    class HashAdapter < BaseAdapter
       TableAdapters.register(:hash, self)
 
-      extend Forwardable
-      include Enumerable
-
       def self.supported?(data)
         case data
         when []
@@ -29,45 +25,171 @@ module Charty
 
       def self.array?(data)
         case data
-        when Array,
-             ->(x) { defined?(Numo::NArray) && x.is_a?(Numo::NArray) },
-             ->(x) { defined?(Daru::Vector) && x.is_a?(Daru::Vector) },
-             ->(x) { defined?(NMatrix) && x.is_a?(NMatrix) }
+        when Charty::Vector
+          true
+        # TODO: Use vector adapter to detect them:
+        when Array, method(:daru_vector?), method(:narray_vector?), method(:nmatrix_vector?),
+             method(:numpy_vector?), method(:pandas_series?)
           true
         else
           false
         end
       end
 
-      def initialize(data, columns: nil)
+      def self.daru_vector?(x)
+        defined?(Daru::Vector) && x.is_a?(Daru::Vector)
+      end
+
+      def self.narray_vector?(x)
+        defined?(Numo::NArray) && x.is_a?(Numo::NArray) && x.ndim == 1
+      end
+
+      def self.nmatrix_vector?(x)
+        defined?(NMatrix) && x.is_a?(NMatrix) && x.dim == 1
+      end
+
+      def self.numpy_vector?(x)
+        defined?(Numpy::NDArray) && x.is_a?(Numpy::NDArray) && x.ndim == 1
+      end
+
+      def self.pandas_series?(x)
+        defined?(Pandas::Series) && x.is_a?(Pandas::Series)
+      end
+
+      def initialize(data, columns: nil, index: nil)
         case data
         when Hash
-          @data = data
+          arrays = data.values
+          columns ||= data.keys
         when Array
           case data[0]
           when Numeric, String, Time, Date
-            data = data.map {|x| [x] }
-            @data = make_data_from_records(data, columns)
+            arrays = [data]
           when Hash
-            # TODO
+            columns ||= data.map(&:keys).inject(&:|)
+            arrays = columns.map { [] }
+            data.each do |record|
+              columns.each_with_index do |key, i|
+                arrays[i] << record[key]
+              end
+            end
           when self.class.method(:array?)
             unsupported_data_format unless data.all?(&self.class.method(:array?))
-            @data = make_data_from_records(data, columns)
+            arrays = data.map(&:to_a).transpose
           else
             unsupported_data_format
           end
         else
           unsupported_data_format
         end
+
+        unless arrays.empty?
+          arrays, columns, index = check_data(arrays, columns, index)
+        end
+
+        @data = arrays.map.with_index {|a, i| [columns[i], a] }.to_h
+        self.columns = columns unless columns.nil?
+        self.index = index unless index.nil?
+      end
+
+      private def check_data(arrays, columns, index)
+        # NOTE: After Ruby 2.7, we can write the following code by filter_map:
+        #         indexes = Util.filter_map(arrays) {|ary| ary.index if ary.is_a?(Charty::Vector) }
+        indexes = []
+        arrays.each do |array|
+          index = case array
+                  when Charty::Vector
+                    array.index
+                  when ->(x) { defined?(Daru) && x.is_a?(Daru::Vector) }
+                    Charty::DaruIndex.new(array.index)
+                  when ->(x) { defined?(Pandas) && x.is_a?(Pandas::Series) }
+                    Charty::PandasIndex.new(array.index)
+                  else
+                    if index.nil?
+                      RangeIndex.new(0 ... array.size)
+                    else
+                      check_and_convert_index(index, :index, array.size)
+                    end
+                  end
+          indexes << index
+        end
+        index = union_indexes(*indexes)
+
+        arrays = arrays.map do |array|
+          case array
+          when Charty::Vector
+            array.data
+          when Hash
+            raise NotImplementedError
+          when self.class.method(:array?)
+            array
+          else
+            Array.try_convert(array)
+          end
+        end
+
+        columns = generate_column_names(arrays.length, columns)
+
+        return arrays, columns, index
+      end
+
+      private def union_indexes(*indexes)
+        result = nil
+        while result.nil? && indexes.length > 0
+          result = indexes.shift
+        end
+        indexes.each do |index|
+          next if index.nil?
+          result = result.union(index)
+        end
+        result
       end
 
+      attr_reader :data
+
       def_delegator :@data, :keys, :column_names
 
+      def length
+        case
+        when column_names.empty?
+          0
+        else
+          data[column_names[0]].size
+        end
+      end
+
+      def column_length
+        data.length
+      end
+
+      def compare_data_equality(other)
+        case other
+        when DaruAdapter, PandasDataFrameAdapter
+          other.compare_data_equality(self)
+        else
+          super
+        end
+      end
+
       def [](row, column)
         if row
           @data[column][row]
         else
-          @data[column]
+          case column
+          when Symbol
+            sym_key = column
+            str_key = column.to_s
+          else
+            str_key = String.try_convert(column)
+            sym_key = str_key.to_sym
+          end
+
+          column_data = if @data.key?(sym_key)
+                          @data[sym_key]
+                        else
+                          @data[str_key]
+                        end
+          Vector.new(column_data, index: index, name: column)
         end
       end
 
@@ -80,6 +202,11 @@ module Charty
         end
       end
 
+      def reset_index
+        index_name = index.name || :index
+        Charty::Table.new({ index_name => index.to_a }.merge(data))
+      end
+
       private def make_data_from_records(data, columns)
         n_rows = data.length
         n_columns = data.map(&:size).max