charty 0.2.3 → 0.2.4

data/lib/charty/table_adapters/daru_adapter.rb

@@ -1,29 +1,63 @@
+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 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
@@ -23,6 +23,10 @@ module Charty
         @table.column_names
       end
 
+      def length
+        data.n_rows
+      end
+
       def each(&block)
         return to_enum(__method__) unless block_given?
 
@@ -37,7 +41,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,47 +25,165 @@ 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
+        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
+            raise NotImplementedError,
+                  "an array of records is not supported"
           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 = arrays.filter_map {|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
 

data/lib/charty/table_adapters/narray_adapter.rb

@@ -1,13 +1,13 @@
 module Charty
   module TableAdapters
-    class NArrayAdapter
+    class NArrayAdapter < BaseAdapter
       TableAdapters.register(:narray, self)
 
       def self.supported?(data)
         defined?(Numo::NArray) && data.is_a?(Numo::NArray) && data.ndim <= 2
       end
 
-      def initialize(data, columns: nil)
+      def initialize(data, columns: nil, index: nil)
         case data.ndim
         when 1
           data = data.reshape(data.length, 1)
@@ -17,23 +17,42 @@ module Charty
           raise ArgumentError, "Unsupported data format"
         end
         @data = data
-        @column_names = generate_column_names(data.shape[1], columns)
+        self.columns = Index.new(generate_column_names(data.shape[1], columns))
+        self.index = index || RangeIndex.new(0 ... length)
       end
 
-      attr_reader :column_names, :data
+      attr_reader :data
+
+      def length
+        data.shape[0]
+      end
+
+      def column_length
+        data.shape[1]
+      end
+
+      def compare_data_equality(other)
+        case other
+        when NArrayAdapter
+          data == other.data
+        else
+          super
+        end
+      end
 
       def [](row, column)
         if row
           @data[row, resolve_column_index(column)]
         else
-          @data[true, resolve_column_index(column)]
+          column_data = @data[true, resolve_column_index(column)]
+          Charty::Vector.new(column_data, index: index, name: column)
         end
       end
 
       private def resolve_column_index(column)
         case column
         when String, Symbol
-          index = column_names.index(column.to_s)
+          index = column_names.index(column.to_sym) || column_names.index(column.to_s)
           return index if index
           raise IndexError, "invalid column name: #{column}"
         when Integer

data/lib/charty/table_adapters/nmatrix_adapter.rb

@@ -1,6 +1,6 @@
 module Charty
   module TableAdapters
-    class NMatrixAdapter
+    class NMatrixAdapter < BaseAdapter
       TableAdapters.register(:nmatrix, self)
 
       def self.supported?(data)
@@ -17,23 +17,33 @@ module Charty
           raise ArgumentError, "Unsupported data format"
         end
         @data = data
-        @column_names = generate_column_names(data.shape[1], columns)
+        self.columns = Index.new(generate_column_names(data.shape[1], columns))
+        self.index = index || RangeIndex.new(0 ... length)
       end
 
-      attr_reader :column_names, :data
+      attr_reader :data
+
+      def length
+        data.shape[0]
+      end
+
+      def column_length
+        data.shape[1]
+      end
 
       def [](row, column)
         if row
           @data[row, resolve_column_index(column)]
         else
-          @data[:*, resolve_column_index(column)].reshape([@data.shape[0]])
+          column_data = @data[:*, resolve_column_index(column)].reshape([@data.shape[0]])
+          Charty::Vector.new(column_data, index: index, name: column)
         end
       end
 
       private def resolve_column_index(column)
         case column
         when String, Symbol
-          index = column_names.index(column.to_s)
+          index = column_names.index(column.to_sym) || column_names.index(column.to_s)
           return index if index
           raise IndexError, "invalid column name: #{column}"
         when Integer

data/lib/charty/table_adapters/pandas_adapter.rb

@@ -0,0 +1,81 @@
+require "forwardable"
+
+module Charty
+  module TableAdapters
+    class PandasDataFrameAdapter < BaseAdapter
+      TableAdapters.register(:pandas_data_frame, self)
+
+      extend Forwardable
+      include Enumerable
+
+      def self.supported?(data)
+        defined?(Pandas::DataFrame) && data.is_a?(Pandas::DataFrame)
+      end
+
+      def initialize(data, columns: nil, index: nil)
+        @data = check_type(Pandas::DataFrame, data, :data)
+
+        self.columns = columns unless columns.nil?
+        self.index = index unless index.nil?
+      end
+
+      attr_reader :data
+
+      def columns
+        PandasIndex.new(data.columns)
+      end
+
+      def columns=(new_columns)
+        case new_columns
+        when PandasIndex
+          data.columns = new_columns.values
+        when Index
+          data.columns = new_columns.to_a
+        else
+          data.columns = new_columns
+        end
+      end
+
+      def index
+        PandasIndex.new(data.index)
+      end
+
+      def index=(new_index)
+        case new_index
+        when PandasIndex
+          data.index = new_index.values
+        when Index
+          data.index = new_index.to_a
+        else
+          data.index = new_index
+        end
+      end
+
+      def column_names
+        @data.columns.to_a
+      end
+
+      def compare_data_equality(other)
+        case other
+        when PandasDataFrameAdapter
+          data.equals(other.data)
+        else
+          super
+        end
+      end
+
+      def [](row, column)
+        if row
+          @data[column][row]
+        else
+          Vector.new(@data[column])
+        end
+      end
+
+      private def check_type(type, data, name)
+        return data if data.is_a?(type)
+        raise TypeError, "#{name} must be a #{type}"
+      end
+    end
+  end
+end