charty 0.2.0 → 0.2.6

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
+      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
+      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,163 @@
+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 length
+        data.shape[0]
+      end
+
+      def columns
+        PandasIndex.new(data.columns)
+      end
+
+      def columns=(new_columns)
+        case new_columns
+        when PandasIndex
+          data.columns = new_columns.values
+          data.columns.name = new_columns.name
+        when Index
+          data.columns = new_columns.to_a
+          data.columns.name = new_columns.name
+        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
+          data.index.name = new_index.name
+        when Index
+          data.index = new_index.to_a
+          data.index.name = new_index.name
+        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
+
+      def drop_na
+        Charty::Table.new(@data.dropna)
+      end
+
+      def sort_values(by, na_position: :last)
+        Charty::Table.new(@data.sort_values(by, na_position: na_position, kind: :mergesort))
+      end
+
+      private def check_type(type, data, name)
+        return data if data.is_a?(type)
+        raise TypeError, "#{name} must be a #{type}"
+      end
+
+      def group_by(_table, grouper, sort, drop_na)
+        GroupBy.new(@data.groupby(by: grouper, sort: sort, dropna: drop_na))
+      end
+
+      def reset_index
+        Charty::Table.new(data.reset_index)
+      end
+
+      class GroupBy < Charty::Table::GroupByBase
+        def initialize(groupby)
+          @groupby = groupby
+        end
+
+        def indices
+          @groupby.indices.map { |k, v|
+            [k, v.to_a]
+          }.to_h
+        end
+
+        def group_keys
+          each_group_key.to_a
+        end
+
+        def each_group_key
+          return enum_for(__method__) unless block_given?
+
+          if PyCall.respond_to?(:iterable)
+            PyCall.iterable(@groupby).each do |key, index|
+              if key.class == PyCall.builtins.tuple
+                key = key.to_a
+              end
+              yield key
+            end
+          else # TODO: Remove this clause after the new PyCall will be released
+            iter = @groupby.__iter__()
+            while true
+              begin
+                key, sub_data = iter.__next__
+                if key.class == PyCall.builtins.tuple
+                  key = key.to_a
+                end
+                yield key
+              rescue PyCall::PyError => error
+                if error.type == PyCall.builtins.StopIteration
+                  break
+                else
+                  raise error
+                end
+              end
+            end
+          end
+        end
+
+        def apply(*args, &block)
+          res = @groupby.apply(->(data) {
+            res = block.call(Charty::Table.new(data), *args)
+            Pandas::Series.new(data: res)
+          })
+          Charty::Table.new(res)
+        end
+
+        def [](key)
+          Charty::Table.new(@groupby.get_group(key))
+        end
+      end
+    end
+  end
+end

data/lib/charty/util.rb

@@ -0,0 +1,28 @@
+module Charty
+  module Util
+    if [].respond_to?(:filter_map)
+      module_function def filter_map(enum, &block)
+        enum.filter_map(&block)
+      end
+    else
+      module_function def filter_map(enum, &block)
+        enum.inject([]) do |acc, x|
+          y = block.call(x)
+          if y
+            acc.push(y)
+          else
+            acc
+          end
+        end
+      end
+    end
+
+    module_function def missing?(val)
+      val.nil? || nan?(val)
+    end
+
+    module_function def nan?(val)
+      val.respond_to?(:nan?) && val.nan?
+    end
+  end
+end

data/lib/charty/vector.rb

@@ -0,0 +1,69 @@
+require "forwardable"
+
+module Charty
+  class Vector
+    extend Forwardable
+    include Enumerable
+
+    def self.try_convert(obj)
+      case obj
+      when self
+        obj
+      else
+        if VectorAdapters.find_adapter_class(obj, exception: false)
+          new(obj)
+        end
+      end
+    end
+
+    def initialize(data, index: nil, name: nil)
+      adapter_class = VectorAdapters.find_adapter_class(data)
+      @adapter = adapter_class.new(data)
+      self.index = index unless index.nil?
+      self.name = name unless name.nil?
+    end
+
+    attr_reader :adapter
+
+    def_delegators :adapter, :data
+    def_delegators :adapter, :index, :index=
+    def_delegators :adapter, :==, :[], :[]=
+
+    def_delegators :adapter, :length
+    def_delegators :adapter, :name, :name=
+
+    alias size length
+
+    def_delegators :adapter, :to_a
+    def_delegators :adapter, :each
+    def_delegators :adapter, :empty?
+
+    def_delegators :adapter, :boolean?, :numeric?, :categorical?
+    def_delegators :adapter, :categories
+    def_delegators :adapter, :unique_values
+    def_delegators :adapter, :group_by
+    def_delegators :adapter, :drop_na
+    def_delegators :adapter, :values_at
+
+    def_delegators :adapter, :eq, :notnull
+
+    alias completecases notnull
+
+    def_delegators :adapter, :mean, :stdev
+
+    # TODO: write test
+    def categorical_order(order=nil)
+      if order.nil?
+        case
+        when categorical?
+          order = categories
+        else
+          order = unique_values.compact
+          order.sort! if numeric?
+        end
+        order.compact!
+      end
+      order
+    end
+  end
+end

data/lib/charty/vector_adapters.rb

@@ -0,0 +1,187 @@
+require "forwardable"
+
+module Charty
+  module VectorAdapters
+    class UnsupportedVectorData < StandardError; end
+
+    @adapters = {}
+
+    def self.register(name, adapter_class)
+      @adapters[name] = adapter_class
+    end
+
+    def self.find_adapter_class(data, exception: true)
+      @adapters.each_value do |adapter_class|
+        return adapter_class if adapter_class.supported?(data)
+      end
+      if exception
+        raise UnsupportedVectorData, "Unsupported vector data (#{data.class})"
+      end
+    end
+
+    class BaseAdapter
+      extend Forwardable
+      include Enumerable
+
+      def self.adapter_name
+        name[/:?(\w+)Adapter\z/, 1]
+      end
+
+      private def check_data(data)
+        return data if self.class.supported?(data)
+        raise UnsupportedVectorData, "Unsupported vector data (#{data.class})"
+      end
+
+      attr_reader :data
+
+      def_delegators :data, :length, :size
+
+      def ==(other)
+        case other.adapter
+        when BaseAdapter
+          return false if other.index != index
+          if respond_to?(:compare_data_equality)
+            compare_data_equality(other.adapter)
+          elsif other.adapter.respond_to?(:compare_data_equality)
+            other.adapter.compare_data_equality(self)
+          else
+            case other.adapter
+            when self.class
+              data == other.data
+            else
+              false
+            end
+          end
+        else
+          super
+        end
+      end
+
+      def_delegators :data, :[], :[]=
+      def_delegators :data, :each, :to_a, :empty?
+
+      # Take values at the given positional indices (without indexing)
+      def values_at(*indices)
+        indices.map {|i| data[i] }
+      end
+
+      def where_in_array(mask)
+        mask = check_mask_vector(mask)
+        masked_data = []
+        masked_index = []
+        mask.each_with_index do |f, i|
+          case f
+          when true, 1
+            masked_data << data[i]
+            masked_index << index[i]
+          end
+        end
+        return masked_data, masked_index
+      end
+
+      private def check_mask_vector(mask)
+        # ensure mask is boolean vector
+        case mask
+        when Charty::Vector
+          unless mask.boolean?
+            raise ArgumentError, "Unable to lookup items by a nonboolean vector"
+          end
+          mask
+        else
+          Charty::Vector.new(mask)
+        end
+      end
+
+      def mean
+        Statistics.mean(data)
+      end
+
+      def stdev(population: false)
+        Statistics.stdev(data, population: population)
+      end
+    end
+
+    module NameSupport
+      attr_reader :name
+
+      def name=(value)
+        @name = check_name(value)
+      end
+
+      private def check_name(value)
+        value = String.try_convert(value) || value
+        case value
+        when String, Symbol
+          value
+        else
+          raise ArgumentError,
+                "name must be a String or a Symbol (#{value.class} is given)"
+        end
+      end
+    end
+
+    module IndexSupport
+      attr_reader :index
+
+      def [](key)
+        case key
+        when Charty::Vector
+          where(key)
+        else
+          super(key_to_loc(key))
+        end
+      end
+
+      def []=(key, val)
+        super(key_to_loc(key), val)
+      end
+
+      private def key_to_loc(key)
+        loc = self.index.loc(key)
+        if loc.nil?
+          if key.respond_to?(:to_int)
+            loc = key.to_int
+          else
+            raise KeyError.new("key not found: %p" % key,
+                               receiver: __method__, key: key)
+          end
+        end
+        loc
+      end
+
+      def index=(values)
+        @index = check_and_convert_index(values, :index, length)
+      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
+
+require_relative "vector_adapters/array_adapter"
+require_relative "vector_adapters/daru_adapter"
+require_relative "vector_adapters/narray_adapter"
+require_relative "vector_adapters/nmatrix_adapter"
+require_relative "vector_adapters/numpy_adapter"
+require_relative "vector_adapters/pandas_adapter"