charty 0.2.6 → 0.2.10

data/lib/charty/plotters/line_plotter.rb

@@ -122,7 +122,7 @@ module Charty
 
       include RandomSupport
 
-      attr_reader :sort, :err_style, :err_kws, :error_bar, :x_scale, :y_scale
+      attr_reader :sort, :err_style, :err_kws, :error_bar
 
       def sort=(val)
         @sort = check_boolean(val, :sort)
@@ -211,17 +211,21 @@ module Charty
         [method, level]
       end
 
+      attr_reader :x_scale
+
       def x_scale=(val)
         @x_scale = check_axis_scale(val, :x)
       end
 
+      attr_reader :y_scale
+
       def y_scale=(val)
         @y_scale = check_axis_scale(val, :y)
       end
 
       private def check_axis_scale(val, axis)
         case val
-        when :linear, "linear", :log10, "log10"
+        when :linear, "linear", :log, "log"
           val.to_sym
         else
           raise ArgumentError,
@@ -252,6 +256,15 @@ module Charty
             sub_data = sub_data.sort_values(sort_cols)
           end
 
+          # Perform axis scaling
+          if x_scale != :linear
+            sub_data[:x] = sub_data[:x].scale(x_scale)
+          end
+          if y_scale != :linear
+            sub_data[:y] = sub_data[:y].scale(x_scale)
+          end
+
+          # Perform estimation and error calculation
           unless estimator.nil?
             if self.variables.include?(:units)
               raise "`estimator` is must be nil when specifying `units`"
@@ -261,7 +274,22 @@ module Charty
             sub_data = grouped.apply(agg_var, &aggregator.method(:aggregate)).reset_index
           end
 
-          # TODO: perform inverse conversion of axis scaling before plot
+          # Perform axis inverse scaling
+          if x_scale != :linear
+            sub_data.column_names.each do |cn|
+              if cn.start_with?("x")
+                sub_data[cn] = sub_data[cn].scale_inverse(x_scale)
+              end
+            end
+          end
+
+          if y_scale != :linear
+            sub_data.column_names.each do |cn|
+              if cn.start_with?("y")
+                sub_data[cn] = sub_data[cn].scale_inverse(x_scale)
+              end
+            end
+          end
 
           unit_grouping = if self.variables.include?(:units)
                             sub_data.group_by(:units).each_group
@@ -290,10 +318,15 @@ 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?
+
+        backend.set_xscale(x_scale)
+        backend.set_yscale(y_scale)
       end
     end
   end

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

@@ -10,6 +10,10 @@ module Charty
       def self.stdev(enum, population: false)
         enum.stdev(population: population)
       end
+
+      def self.histogram(ary, *args, **kwargs)
+        ary.histogram(*args, **kwargs)
+      end
     rescue LoadError
       def self.mean(enum)
         xs = enum.to_a
@@ -24,6 +28,11 @@ module Charty
         var = xs.map {|x| (x - mean)**2 }.sum / (n - ddof)
         Math.sqrt(var)
       end
+
+      def self.histogram(ary, *args, **kwargs)
+        raise NotImplementedError,
+              "histogram is currently supported only with enumerable-statistics"
+      end
     end
 
     def self.bootstrap(vector, n_boot: 2000, func: :mean, units: nil, random: nil)

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/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
 
@@ -79,6 +81,9 @@ module Charty
           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
@@ -176,6 +181,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
@@ -189,8 +199,56 @@ module Charty
                         else
                           @data[str_key]
                         end
-          Vector.new(column_data, index: index, name: column)
+          # FIXME: Here column_data need to be dupped to
+          # prevent to overwrite the name of Pandas::Series
+          Vector.new(column_data.dup, index: index, name: column)
+        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
+        case values
+        when Charty::Vector
+          values = values.data
+        else
+          values = Array.try_convert(values)
         end
+        if values.nil?
+          raise ArgumentError,
+                "`values` must be convertible to Array"
+        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

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)