charty 0.2.7 → 0.2.11

data/lib/charty/plotters/scatter_plotter.rb

@@ -70,8 +70,10 @@ module Charty
       end
 
       private def annotate_axes(backend)
-        xlabel = self.variables[:x]
-        ylabel = self.variables[:y]
+        backend.set_title(self.title) if self.title
+
+        xlabel = self.x_label || self.variables[:x]
+        ylabel = self.y_label || self.variables[:y]
         backend.set_xlabel(xlabel) unless xlabel.nil?
         backend.set_ylabel(ylabel) unless ylabel.nil?
       end

data/lib/charty/statistics.rb

@@ -109,9 +109,9 @@ module Charty
       a = a.sort
       n = a.size
       q.map do |x|
-        x = n * (x / 100.0)
+        x = (n-1) * (x / 100.0)
         i = x.floor
-        if i == n-1
+        if i == x
           a[i]
         else
           t = x - i

data/lib/charty/table.rb

@@ -32,20 +32,7 @@ module Charty
     def_delegators :adapter, :columns, :columns=
     def_delegators :adapter, :index, :index=
 
-    def_delegator :@adapter, :column_names
-
-    def column?(name)
-      return true if column_names.include?(name)
-
-      case name
-      when String
-        column_names.include?(name.to_sym)
-      when Symbol
-        column_names.include?(name.to_s)
-      else
-        false
-      end
-    end
+    def_delegators :@adapter, :column_names, :column?
 
     def_delegator :@adapter, :data, :raw_data
 
@@ -65,17 +52,35 @@ module Charty
     end
 
     def [](key)
-      key = case key
-            when Symbol
-              key
-            else
-              String.try_convert(key).to_sym
-            end
-      if @column_cache.key?(key)
-        @column_cache[key]
+      case key
+      when Array
+        @adapter[nil, key]
+      else
+        key = case key
+              when Symbol
+                key
+              else
+                String.try_convert(key).to_sym
+              end
+        if @column_cache.key?(key)
+          @column_cache[key]
+        else
+          @column_cache[key] = @adapter[nil, key]
+        end
+      end
+    end
+
+    def []=(key, values)
+      case key
+      when Array
+        raise ArgumentError,
+              "Substituting multiple keys is not supported"
+      when Symbol
+        # do nothing
       else
-        @column_cache[key] = @adapter[nil, key]
+        key = key.to_str.to_sym
       end
+      @adapter[key] = values
     end
 
     def group_by(grouper, sort: true, drop_na: true)
@@ -123,6 +128,8 @@ module Charty
 
     def_delegator :adapter, :reset_index
 
+    def_delegator :adapter, :melt
+
     class GroupByBase
     end
 

data/lib/charty/table_adapters/arrow_adapter.rb

@@ -0,0 +1,53 @@
+module Charty
+  module TableAdapters
+    class ArrowAdapter < BaseAdapter
+      TableAdapters.register(:arrow, self)
+
+      def self.supported?(data)
+        defined?(Arrow::Table) && data.is_a?(Arrow::Table)
+      end
+
+      def initialize(data)
+        @data = data
+        @column_names = @data.columns.map(&:name)
+        self.columns = Index.new(@column_names)
+        self.index = RangeIndex.new(0 ... length)
+      end
+
+      attr_reader :data
+
+      def length
+        @data.n_rows
+      end
+
+      def column_length
+        @column_names.length
+      end
+
+      def compare_data_equality(other)
+        case other
+        when ArrowAdapter
+          data == other.data
+        else
+          super
+        end
+      end
+
+      def [](row, column)
+        if row
+          @data[column][row]
+        else
+          case column
+          when Array
+            Table.new(@data.select_columns(*column))
+          else
+            column_data = @data[column]
+            Vector.new(column_data.data.combine,
+                       index: index,
+                       name: column_data.name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/charty/table_adapters/base_adapter.rb

@@ -16,6 +16,19 @@ module Charty
         columns.to_a
       end
 
+      def column?(name)
+        return true if column_names.include?(name)
+
+        case name
+        when String
+          column_names.include?(name.to_sym)
+        when Symbol
+          column_names.include?(name.to_s)
+        else
+          false
+        end
+      end
+
       attr_reader :index
 
       def index=(values)
@@ -126,6 +139,81 @@ module Charty
         )
       end
 
+      def melt(id_vars: nil, value_vars: nil, var_name: nil, value_name: :value)
+        if column?(value_name)
+          raise ArgumentError,
+                "The value of `value_name` must not be matched to the existing column names."
+        end
+
+        case value_name
+        when Symbol
+          # do nothing
+        else
+          value_name = value.to_str.to_sym
+        end
+
+        id_vars = check_melt_vars(id_vars, :id_vars)
+        value_vars = check_melt_vars(value_vars, :value_vars) { self.column_names }
+        value_vars -= id_vars
+
+        case var_name
+        when nil
+          var_name = self.columns.name
+          var_name = :variable if var_name.nil?
+        when Symbol
+          # do nothing
+        else
+          var_name = var_name.to_str
+        end
+        var_name = var_name.to_sym
+
+        n_batch_rows = self.length
+        n_target_columns = value_vars.length
+        melted_data = id_vars.map { |cn|
+          id_values = self[nil, cn].to_a
+          [cn.to_sym, id_values * n_target_columns]
+        }.to_h
+
+        melted_data[var_name] = value_vars.map { |cn| Array.new(n_batch_rows, cn) }.flatten
+
+        melted_data[value_name] = value_vars.map { |cn| self[nil, cn].to_a }.flatten
+
+        Charty::Table.new(melted_data)
+      end
+
+      private def check_melt_vars(val, name)
+        if val.nil?
+          val = if block_given?
+                  yield
+                else
+                  []
+                end
+        end
+        case val
+        when nil
+          nil
+        when Array
+          missing = val.reject {|cn| self.column?(cn) }
+          if missing.empty?
+            val.map do |v|
+              case v
+              when Symbol
+                v.to_s
+              else
+                v.to_str
+              end
+            end
+          else
+            raise ArgumentError,
+                  "Missing column names in `#{name}` (%s)" % missing.join(", ")
+          end
+        when Symbol
+          [val.to_s]
+        else
+          [val.to_str]
+        end
+      end
+
       private def check_na_position(val)
         case val
         when :first, "first"

data/lib/charty/table_adapters/daru_adapter.rb

@@ -57,12 +57,52 @@ module Charty
           column_data = if @data.has_vector?(column)
                           @data[column]
                         else
-                          @data[column.to_s]
+                          case column
+                          when String
+                            @data[column.to_sym]
+                          else
+                            @data[column.to_s]
+                          end
                         end
           Vector.new(column_data)
         end
       end
 
+      def []=(key, values)
+        case key
+        when Symbol
+          sym_key = key
+          str_key = key.to_s
+        else
+          str_key = key.to_str
+          sym_key = str_key.to_sym
+        end
+        case
+        when @data.has_vector?(sym_key)
+          key = sym_key
+        when @data.has_vector?(str_key)
+          key = str_key
+        end
+
+        case values
+        when Charty::Vector
+          case values.adapter
+          when Charty::VectorAdapters::DaruVectorAdapter
+            @data[key] = values.adapter.data
+          else
+            @data[key] = values.to_a
+          end
+        else
+          orig_values = values
+          values = Array.try_convert(values)
+          if values.nil?
+            raise ArgumentError, "`values` must be convertible to Array"
+          end
+          @data[key] = values
+        end
+        return values
+      end
+
       private def check_type(type, data, name)
         return data if data.is_a?(type)
         raise TypeError, "#{name} must be a #{type}"

data/lib/charty/table_adapters/hash_adapter.rb

@@ -20,6 +20,8 @@ module Charty
           end
         when Hash
           true
+        when ->(x) { defined?(CSV::Table) && x.is_a?(CSV::Table) }
+          true
         end
       end
 
@@ -73,12 +75,17 @@ module Charty
                 arrays[i] << record[key]
               end
             end
+          when Vector
+            arrays = data
           when self.class.method(:array?)
             unsupported_data_format unless data.all?(&self.class.method(:array?))
             arrays = data.map(&:to_a).transpose
           else
             unsupported_data_format
           end
+        when ->(x) { defined?(CSV::Table) && x.is_a?(CSV::Table) }
+          columns ||= data.headers
+          arrays = data.headers.map {|x| data[x] }
         else
           unsupported_data_format
         end
@@ -116,20 +123,15 @@ module Charty
         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
+          Vector.try_convert(array)
         end
 
         columns = generate_column_names(arrays.length, columns)
 
+        arrays.zip(columns) do |array, column|
+          array.name = column.to_sym if array.name.to_s != column
+        end
+
         return arrays, columns, index
       end
 
@@ -176,6 +178,11 @@ module Charty
           @data[column][row]
         else
           case column
+          when Array
+            slice_data = column.map { |cn|
+              [cn, self[nil, cn]]
+            }.to_h
+            return Charty::Table.new(slice_data, index: self.index)
           when Symbol
             sym_key = column
             str_key = column.to_s
@@ -193,6 +200,47 @@ module Charty
         end
       end
 
+      def []=(key, values)
+        case key
+        when Symbol
+          str_key = key.to_s
+          sym_key = key
+        else
+          str_key = key.to_str
+          sym_key = str_key.to_sym
+        end
+
+        orig_values = values
+        values = Vector.try_convert(values)
+        if values.nil?
+          raise ArgumentError,
+                "`values` must be convertible to Charty::Vector"
+        end
+
+        if values.length != self.length
+          raise ArgumentError,
+                "`values` length does not match the length of the table"
+        end
+
+        if @data.key?(sym_key)
+          @data[sym_key] = values
+        elsif @data.key?(str_key)
+          @data[str_key] = values
+        elsif key == sym_key
+          @data[sym_key] = values
+          new_column = sym_key
+        else
+          @data[str_key] = values
+          new_column = sym_key
+        end
+
+        if new_column
+          self.columns = Index.new([*self.columns, new_column])
+        end
+
+        values
+      end
+
       def each
         i, n = 0, shape[0]
         while i < n

data/lib/charty/table_adapters/pandas_adapter.rb

@@ -42,6 +42,10 @@ module Charty
         end
       end
 
+      def column?(name)
+        data.__contains__(name)
+      end
+
       def index
         PandasIndex.new(data.index)
       end
@@ -76,8 +80,33 @@ module Charty
         if row
           @data[column][row]
         else
-          Vector.new(@data[column])
+          case column
+          when Array
+            Table.new(@data[column])
+          else
+            Vector.new(@data[column])
+          end
+        end
+      end
+
+      def []=(key, values)
+        case values
+        when Charty::Vector
+          case values.adapter
+          when Charty::VectorAdapters::PandasSeriesAdapter
+            @data[key] = values.adapter.data
+          else
+            @data[key] = values.to_a
+          end
+        else
+          orig_values = values
+          values = Array.try_convert(values)
+          if values.nil?
+            raise ArgumentError, "`values` must be convertible to Array"
+          end
+          @data[key] = values
         end
+        return values
       end
 
       def drop_na
@@ -101,6 +130,15 @@ module Charty
         Charty::Table.new(data.reset_index)
       end
 
+      def melt(id_vars: nil, value_vars: nil, var_name: nil, value_name: :value)
+        id_vars = check_melt_vars(id_vars, :id_vars) { nil }
+        value_vars = check_melt_vars(value_vars, :value_vars) { nil }
+
+        Charty::Table.new(data.melt(id_vars: id_vars, value_vars: value_vars,
+                                    var_name: var_name, value_name: value_name,
+                                    ignore_index: true))
+      end
+
       class GroupBy < Charty::Table::GroupByBase
         def initialize(groupby)
           @groupby = groupby
@@ -116,6 +154,7 @@ module Charty
           each_group_key.to_a
         end
 
+        # TODO: test
         def each_group_key
           return enum_for(__method__) unless block_given?
 
@@ -146,6 +185,15 @@ module Charty
           end
         end
 
+        # TODO: test
+        def each_group
+          return enum_for(__method__) unless block_given?
+
+          each_group_key do |key|
+            yield(Array(key), self[key])
+          end
+        end
+
         def apply(*args, &block)
           res = @groupby.apply(->(data) {
             res = block.call(Charty::Table.new(data), *args)