charty 0.2.9 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37ead1e86203bd6580125f4ed97039c6b512e9ae3037a0bc386743ee436f184c
-  data.tar.gz: a94e66292a866acde67c0cfc51bd8eebd5840af68e2d4112caafce80bdd37ed2
+  metadata.gz: d885d476eadfadd3f76f138707ffaf6166eec006b4528fb19c3acce0b97b1c85
+  data.tar.gz: 0630f23f19b65177f3b6dc238717a81a019f9dfa40a40c143d71dcc5c5f760f0
 SHA512:
-  metadata.gz: b518be17e0ae85405285fe22022bc698d0c080e08a0682f055ae70c97655ed313038e6e2899b7c961bd73c0afe1b6b0c25bdb2085bd3a66dddd57d3e6245df55
-  data.tar.gz: 0bc460c78d178b098c65ab8737efddac0a8484abd920282d185533b72396f0abad62ea247be9e8af4286a70b7a4dc2069e88ff1675ba446af65b5c67edfb59d8
+  metadata.gz: 535a69b8d794ccbd30b4328f3188c8a8b50c850cfd84285f79b31162296a9d981313e561ea1089a68be3368b7eb1c83ccc3cb2ff511b8f79aef77e544e261bbe
+  data.tar.gz: 804de2468433db38b5381bcbccab4c28e84c7592bce5c5a98a539ce99c589449759e65ffe7f2e808bd3c5cb5e002ee2219219111561f66f590dbb0ac2c0757bc

data/examples/bar_plot.rb

@@ -0,0 +1,19 @@
+# This example generates box_plot results in README.md
+
+require "charty"
+require "datasets"
+require "matplotlib"
+
+Charty::Backends.use(:pyplot)
+Matplotlib.use(:agg)
+
+penguins = Datasets::Penguins.new
+
+Charty.bar_plot(data: penguins, x: :species, y: :body_mass_g)
+      .save("penguins_species_body_mass_g_bar_plot_v.png")
+
+Charty.bar_plot(data: penguins, x: :body_mass_g, y: :species)
+      .save("penguins_species_body_mass_g_bar_plot_h.png")
+
+Charty.bar_plot(data: penguins, x: :species, y: :body_mass_g, color: :sex)
+      .save("penguins_species_body_mass_g_sex_bar_plot_v.png")

data/examples/box_plot.rb

@@ -0,0 +1,17 @@
+require "charty"
+require "datasets"
+require "matplotlib"
+
+Charty::Backends.use(:pyplot)
+Matplotlib.use(:agg)
+
+penguins = Datasets::Penguins.new
+
+Charty.box_plot(data: penguins, x: :species, y: :body_mass_g)
+      .save("penguins_species_body_mass_g_box_plot_v.png")
+
+Charty.box_plot(data: penguins, x: :body_mass_g, y: :species)
+      .save("penguins_species_body_mass_g_box_plot_h.png")
+
+Charty.box_plot(data: penguins, x: :species, y: :body_mass_g, color: :sex)
+      .save("penguins_species_body_mass_g_sex_box_plot_v.png")

data/examples/scatter_plot.rb

@@ -0,0 +1,17 @@
+require "charty"
+require "datasets"
+require "matplotlib"
+
+Charty::Backends.use(:pyplot)
+Matplotlib.use(:agg)
+
+penguins = Datasets::Penguins.new
+
+Charty.scatter_plot(data: penguins, x: :body_mass_g, y: :flipper_length_mm)
+      .save("penguins_body_mass_g_flipper_length_mm_scatter_plot.png")
+
+Charty.scatter_plot(data: penguins, x: :body_mass_g, y: :flipper_length_mm, color: :species)
+      .save("penguins_body_mass_g_flipper_length_mm_species_scatter_plot.png")
+
+Charty.scatter_plot(data: penguins, x: :body_mass_g, y: :flipper_length_mm, color: :species, style: :sex)
+      .save("penguins_body_mass_g_flipper_length_mm_species_sex_scatter_plot.png")

data/lib/charty/backends/plotly.rb

@@ -134,10 +134,8 @@ module Charty
 
         if orient == :v
           x, y = bar_pos, values
-          x = group_names unless group_names.nil?
         else
           x, y = values, bar_pos
-          y = group_names unless group_names.nil?
         end
 
         trace = {
@@ -241,9 +239,9 @@ module Charty
           }
 
           if orient == :v
-            trace.update(y: values, x: group_keys)
+            trace.update(y: values, x: group_keys.map(&:to_s))
           else
-            trace.update(x: values, y: group_keys)
+            trace.update(x: values, y: group_keys.map(&:to_s))
           end
 
           trace
@@ -613,6 +611,11 @@ module Charty
         end
       end
 
+      def set_title(title)
+        @layout[:title] ||= {}
+        @layout[:title][:text] = title
+      end
+
       def set_xlabel(label)
         @layout[:xaxis] ||= {}
         @layout[:xaxis][:title] = label
@@ -657,6 +660,29 @@ module Charty
         @layout[:yaxis][:range] = [min, max]
       end
 
+      def set_xscale(scale)
+        scale = check_scale_type(scale, :xscale)
+        @layout[:xaxis] ||= {}
+        @layout[:xaxis][:type] = scale
+      end
+
+      def set_yscale(scale)
+        scale = check_scale_type(scale, :yscale)
+        @layout[:yaxis] ||= {}
+        @layout[:yaxis][:type] = scale
+      end
+
+      private def check_scale_type(val, name)
+        case
+        when :linear, :log
+          val
+        else
+          raise ArgumentError,
+                "Invalid #{name} type: %p" % val,
+                caller
+        end
+      end
+
       def disable_xaxis_grid
         # do nothing
       end

data/lib/charty/backends/plotly_helpers/notebook_renderer.rb

@@ -7,7 +7,7 @@ module Charty
           @initialized = false
         end
 
-        def activate()
+        def activate
           return if @initialized
 
           unless IRubyHelper.iruby_notebook?
@@ -50,6 +50,8 @@ module Charty
             END_SCRIPT
           end
           IRuby.display(script, mime: "text/html")
+          @initialized = true
+          nil
         end
 
         def render(figure, element_id: nil, post_script: nil)

data/lib/charty/backends/pyplot.rb

@@ -662,6 +662,10 @@ module Charty
         end
       end
 
+      def set_title(title)
+        @pyplot.gca.set_title(String(title))
+      end
+
       def set_xlabel(label)
         @pyplot.gca.set_xlabel(String(label))
       end
@@ -694,6 +698,27 @@ module Charty
         @pyplot.gca.set_ylim(Float(min), Float(max))
       end
 
+      def set_xscale(scale)
+        scale = check_scale_type(scale, :xscale)
+        @pyplot.gca.set_xscale(scale)
+      end
+
+      def set_yscale(scale)
+        scale = check_scale_type(scale, :yscale)
+        @pyplot.gca.set_yscale(scale)
+      end
+
+      private def check_scale_type(val, name)
+        case
+        when :linear, :log
+          val
+        else
+          raise ArgumentError,
+                "Invalid #{name} type: %p" % val,
+                caller
+        end
+      end
+
       def disable_xaxis_grid
         @pyplot.gca.xaxis.grid(false)
       end
@@ -715,6 +740,11 @@ module Charty
         nil
       end
 
+      def render_mimebundle(include: [], exclude: [])
+        show
+        {}
+      end
+
       SAVEFIG_OPTIONAL_PARAMS = [
         :dpi, :quality, :optimize, :progressive, :facecolor, :edgecolor,
         :orientation, :papertype, :transparent, :bbox_inches, :pad_inches,

data/lib/charty/backends/unicode_plot.rb

@@ -16,7 +16,7 @@ module Charty
         @layout = {}
       end
 
-      def bar(bar_pos, values, color: nil)
+      def bar(bar_pos, _group_names, values, colors, _orient, **kwargs)
         @figure = {
           type: :bar,
           bar_pos: bar_pos,
@@ -24,7 +24,7 @@ module Charty
         }
       end
 
-      def box_plot(plot_data, positions, color:, gray:)
+      def box_plot(plot_data, positions, **kwargs)
         @figure = { type: :box, data: plot_data }
       end
 
@@ -52,13 +52,13 @@ module Charty
         # do nothing
       end
 
-      def show
-        case @figure[:type]
-        when :bar
-          plot = ::UnicodePlot.barplot(@layout[:xtick_labels], @figure[:values], xlabel: @layout[:xlabel])
-        when :box
-          plot = ::UnicodePlot.boxplot(@layout[:xtick_labels], @figure[:data], xlabel: @layout[:xlabel])
-        end
+      def render(**kwargs)
+        plot = case @figure[:type]
+                when :bar
+                  ::UnicodePlot.barplot(@layout[:xtick_labels], @figure[:values], xlabel: @layout[:xlabel])
+                when :box
+                  ::UnicodePlot.boxplot(@layout[:xtick_labels], @figure[:data], xlabel: @layout[:xlabel])
+                end
         sio = StringIO.new
         class << sio
           def tty?; true; end

data/lib/charty/plot_methods.rb

@@ -23,19 +23,24 @@ module Charty
     # @param cap_size  Width of the caps on error bars.
     # @param dodge  [true,false]  If true, bar position is shifted along the
     #        categorical axis for avoid overlapping when the color-dimension is used.
+    # @param log  [true,false]  Set the value-axis (e.g. Y-axis if orient is :v) to be log scale.
+    # @param x_label [String,Symbol,#to_str,nil]  X-axis label.
+    # @param y_label [String,Symbol,#to_str,nil]  Y-axis label.
+    # @param title [String,Symbol,#to_str,nil]  Title text.
     def bar_plot(x: nil, y: nil, color: nil, data: nil,
                  order: nil, color_order: nil,
                  estimator: :mean, ci: 95, n_boot: 1000, units: nil, random: nil,
                  orient: nil, key_color: nil, palette: nil, saturation: 1r,
                  error_color: [0.26, 0.26, 0.26], error_width: nil, cap_size: nil,
-                 dodge: true, **options, &block)
+                 dodge: true, log: false, x_label: nil, y_label: nil, title: nil,
+                 **options, &block)
       Plotters::BarPlotter.new(
         data: data, variables: { x: x, y: y, color: color },
         order: order, orient: orient,
         estimator: estimator, ci: ci, n_boot: n_boot, units: units, random: random,
         color_order: color_order, key_color: key_color, palette: palette, saturation: saturation,
         error_color: error_color, error_width: error_width, cap_size: cap_size,
-        dodge: dodge,
+        dodge: dodge, log: log, x_label: x_label, y_label: y_label, title: title,
         **options, &block
       )
     end
@@ -43,7 +48,8 @@ module Charty
     def count_plot(x: nil, y: nil, color: nil, data: nil,
                    order: nil, color_order: nil,
                    orient: nil, key_color: nil, palette: nil, saturation: 1r,
-                   dodge: true, **options, &block)
+                   dodge: true, log: false, x_label: nil, y_label: nil, title: nil,
+                   **options, &block)
       case
       when x.nil? && !y.nil?
         x = y
@@ -70,6 +76,9 @@ module Charty
         palette: palette,
         saturation: saturation,
         dodge: dodge,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
         **options
       ) do |plotter|
         plotter.value_label = "count"
@@ -106,11 +115,15 @@ module Charty
     # @param whisker  Propotion of the IQR past the low and high quartiles to
     #        extend the plot whiskers.  Points outside of this range will be
     #        treated as outliers.
+    # @param x_label [String,Symbol,#to_str,nil]  X-axis label.
+    # @param y_label [String,Symbol,#to_str,nil]  Y-axis label.
+    # @param title [String,Symbol,#to_str,nil]  Title text.
     def box_plot(x: nil, y: nil, color: nil, data: nil,
                  order: nil, color_order: nil,
                  orient: nil, key_color: nil, palette: nil, saturation: 1r,
                  width: 0.8r, dodge: true, flier_size: 5, line_width: nil,
-                 whisker: 1.5, **options, &block)
+                 whisker: 1.5, x_label: nil, y_label: nil, title: nil,
+                 **options, &block)
       Plotters::BoxPlotter.new(
         data: data,
         variables: { x: x, y: y, color: color },
@@ -125,6 +138,9 @@ module Charty
         flier_size: flier_size,
         line_width: line_width,
         whisker: whisker,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
         **options,
         &block
       )
@@ -164,13 +180,18 @@ module Charty
     #        :full, every group will get an entry in the legend.  If :auto,
     #        choose between brief or full representation based on number of
     #        levels.  If false, no legend data is added and no legend is drawn.
+    # @param x_label [String,Symbol,#to_str,nil]  X-axis label.
+    # @param y_label [String,Symbol,#to_str,nil]  Y-axis label.
+    # @param title [String,Symbol,#to_str,nil]  Title text.
     def line_plot(x: nil, y: nil, color: nil, style: nil, size: nil,
                   data: nil, key_color: nil, palette: nil, color_order: nil,
                   color_norm: nil, sizes: nil, size_order: nil, size_norm: nil,
                   markers: nil, dashes: true, style_order: nil,
                   units: nil, estimator: :mean, n_boot: 1000, random: nil,
                   sort: true, err_style: :band, err_params: nil, error_bar: [:ci, 95],
-                  x_scale: :linear, y_scale: :linear, legend: :auto, **options, &block)
+                  x_scale: :linear, y_scale: :linear, legend: :auto,
+                  x_label: nil, y_label: nil, title: nil,
+                  **options, &block)
       Plotters::LinePlotter.new(
         data: data,
         variables: { x: x, y: y, color: color, style: style, size: size },
@@ -195,6 +216,9 @@ module Charty
         x_scale: x_scale,
         y_scale: y_scale,
         legend: legend,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
         **options,
         &block
       )
@@ -225,11 +249,14 @@ module Charty
     #        :full, every group will get an entry in the legend.  If :auto,
     #        choose between brief or full representation based on number of
     #        levels.  If false, no legend data is added and no legend is drawn.
+    # @param x_label [String,Symbol,#to_str,nil]  X-axis label.
+    # @param y_label [String,Symbol,#to_str,nil]  Y-axis label.
+    # @param title [String,Symbol,#to_str,nil]  Title text.
     def scatter_plot(x: nil, y: nil, color: nil, style: nil, size: nil,
                      data: nil, key_color: nil, palette: nil, color_order: nil,
                      color_norm: nil, sizes: nil, size_order: nil, size_norm: nil,
                      markers: true, style_order: nil, alpha: nil, legend: :auto,
-                     **options, &block)
+                     x_label: nil, y_label: nil, title: nil, **options, &block)
       Plotters::ScatterPlotter.new(
         data: data,
         variables: { x: x, y: y, color: color, style: style, size: size },
@@ -244,6 +271,9 @@ module Charty
         style_order: style_order,
         alpha: alpha,
         legend: legend,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
         **options,
         &block
       )
@@ -253,7 +283,8 @@ module Charty
                   stat: :count, bins: :auto,
                   bin_range: nil, common_bins: true,
                   key_color: nil, palette: nil, color_order: nil, color_norm: nil,
-                  legend: true, **options, &block)
+                  legend: true, x_label: nil, y_label: nil, title: nil,
+                  **options, &block)
       # TODO: support following arguments
       # - wiehgts
       # - binwidth
@@ -287,6 +318,9 @@ module Charty
         color_order: color_order,
         color_norm: color_norm,
         legend: legend,
+        x_label: x_label,
+        y_label: y_label,
+        title: title,
         **options,
         &block)
     end

data/lib/charty/plotters/abstract_plotter.rb

@@ -35,6 +35,8 @@ module Charty
       end
 
       def data=(data)
+        # TODO: Convert a Charty::Vector to a Charty::Table so that
+        # the Charty::Vector is handled as a wide form data
         @data = case data
                 when nil, Charty::Table
                   data
@@ -81,6 +83,24 @@ module Charty
                    end
       end
 
+      attr_reader :x_label
+
+      def x_label=(val)
+        @x_label = check_string(val, :x_label, allow_nil: true)
+      end
+
+      attr_reader :y_label
+
+      def y_label=(val)
+        @y_label = check_string(val, :y_label, allow_nil: true)
+      end
+
+      attr_reader :title
+
+      def title=(val)
+        @title = check_string(val, :title, allow_nil: true)
+      end
+
       private def substitute_options(options)
         options.each do |key, val|
           send("#{key}=", val)
@@ -138,6 +158,27 @@ module Charty
         end
       end
 
+      private def check_string(value, name, allow_nil: false)
+        case value
+        when Symbol
+          value.to_s
+        else
+          if allow_nil && value.nil?
+            nil
+          else
+            orig_value = value
+            value = String.try_convert(value)
+            if value.nil?
+              raise ArgumentError,
+                "`#{name}` must be convertible to String: %p" % orig_value,
+                caller
+            else
+              value
+            end
+          end
+        end
+      end
+
       private def variable_type(vector, boolean_type=:numeric)
         if vector.numeric?
           :numeric
@@ -181,15 +222,6 @@ module Charty
         data = processed ? processed_data : plot_data
         data = data.drop_na if drop_na
 
-        levels = var_levels.dup
-
-        ([:x, :y] & grouping_vars).each do |axis|
-          levels[axis] = plot_data[axis].categorical_order()
-          if processed
-            # TODO: perform inverse conversion of axis scaling here
-          end
-        end
-
         if not grouping_vars.empty?
           grouped = data.group_by(grouping_vars, sort: false)
           grouped.each_group do |group_key, group_data|

data/lib/charty/plotters/bar_plotter.rb

@@ -42,6 +42,12 @@ module Charty
         @cap_size = check_number(cap_size, :cap_size, allow_nil: true)
       end
 
+      attr_reader :log
+
+      def log=(val)
+        @log = check_boolean(val, :log)
+      end
+
       private def render_plot(backend, **)
         draw_bars(backend)
         annotate_axes(backend)
@@ -81,6 +87,39 @@ module Charty
         end
       end
 
+      private def annotate_axes(backend)
+        super
+
+        if self.log
+          min_value, max_value = @estimations.minmax
+          if @plot_colors
+            unless @conf_int.empty?
+              min_value = [min_value, @conf_int[0]].min
+              max_value = [max_value, @conf_int[1]].max
+            end
+          else
+            ci_min = Util.filter_map(@conf_int) { |ci| ci[0] unless ci.empty? }
+            ci_max = Util.filter_map(@conf_int) { |ci| ci[1] unless ci.empty? }
+            min_value = [min_value, ci_min.min].min unless ci_min.empty?
+            max_value = [max_value, ci_max.max].max unless ci_max.empty?
+          end
+          if min_value > 1
+            min_value = 0
+          else
+            min_value = Math.log10(min_value).floor
+          end
+          max_value = Math.log10(max_value).ceil
+          case self.orient
+          when :v
+            backend.set_yscale(:log)
+            backend.set_ylim(min_value, max_value)
+          else
+            backend.set_xscale(:log)
+            backend.set_xlim(min_value, max_value)
+          end
+        end
+      end
+
       private def setup_estimations
         if @color_names.nil?
           setup_estimations_with_single_color_group

data/lib/charty/plotters/categorical_plotter.rb

@@ -134,6 +134,7 @@ module Charty
         order = @order # TODO: supply order via parameter
         unless order
           order = @data.column_names.select do |cn|
+            # TODO: Use Charty::Vector#numeric?
             @data[cn].all? {|x| Float(x, exception: false) }
           end
         end
@@ -230,6 +231,7 @@ module Charty
           end
           return :h
         end
+
         case orient
         when :v
           if require_numeric && y_type != :numeric
@@ -263,7 +265,9 @@ module Charty
       private def group_long_form(vals, groups, group_order)
         grouped_vals = vals.group_by(groups)
 
-        plot_data = group_order.map {|g| grouped_vals[g] || [] }
+        plot_data = group_order.map do |g|
+          grouped_vals[g] || Charty::Vector.new([])
+        end
 
         if vals.respond_to?(:name)
           value_label = vals.name
@@ -347,11 +351,15 @@ module Charty
       end
 
       private def annotate_axes(backend)
+        backend.set_title(self.title) if self.title
+
         if orient == :v
           xlabel, ylabel = @group_label, @value_label
         else
           xlabel, ylabel = @value_label, @group_label
         end
+        xlabel = self.x_label if self.x_label
+        ylabel = self.y_label if self.y_label
         backend.set_xlabel(xlabel) unless xlabel.nil?
         backend.set_ylabel(ylabel) unless ylabel.nil?
 

data/lib/charty/plotters/distribution_plotter.rb

@@ -3,7 +3,14 @@ module Charty
     class DistributionPlotter < AbstractPlotter
       def flat_structure
         {
-          x: :values
+          x: :@values
+        }
+      end
+
+      def wide_structure
+        {
+          x: :@values,
+          color: :@columns
         }
       end
 
@@ -71,7 +78,6 @@ module Charty
           return
         end
 
-        # TODO: detect flat data
         flat = data.is_a?(Charty::Vector)
         if flat
           @plot_data = {}
@@ -79,10 +85,10 @@ module Charty
 
           [:x, :y].each do |var|
             case self.flat_structure[var]
-            when :index
+            when :@index
               @plot_data[var] = data.index.to_a
               @variables[var] = data.index.name
-            when :values
+            when :@values
               @plot_data[var] = data.to_a
               @variables[var] = data.name
             end
@@ -90,8 +96,32 @@ module Charty
 
           @plot_data = Charty::Table.new(@plot_data)
         else
-          raise NotImplementedError,
-                "wide-form input is not supported"
+          numeric_columns = @data.column_names.select do |cn|
+            @data[cn].numeric?
+          end
+          wide_data = @data[numeric_columns]
+
+          melt_params = {var_name: :@columns, value_name: :@values }
+          if self.wide_structure.include?(:index)
+            melt_params[:id_vars] = :@index
+          end
+
+          @plot_data = wide_data.melt(**melt_params)
+          @variables = {}
+          self.wide_structure.each do |var, attr|
+            @plot_data[var] = @plot_data[attr]
+
+            @variables[var] = case attr
+                              when :@columns
+                                wide_data.columns.name
+                              when :@index
+                                wide_data.index.name
+                              else
+                                nil
+                              end
+          end
+
+          @plot_data = @plot_data[self.wide_structure.keys]
         end
       end
 

data/lib/charty/plotters/histogram_plotter.rb

@@ -220,14 +220,16 @@ module Charty
       end
 
       private def annotate_axes(backend)
+        backend.set_title(self.title) if self.title
+
         if univariate?
-          xlabel = self.variables[:x]
-          ylabel = self.variables[:y]
+          xlabel = self.x_label || self.variables[:x]
+          ylabel = self.y_label || self.variables[:y]
           case self.univariate_variable
           when :x
-            ylabel = self.stat.to_s.capitalize
+            ylabel ||= self.stat.to_s.capitalize
           else
-            xlabel = self.stat.to_s.capitalize
+            xlabel ||= self.stat.to_s.capitalize
           end
           backend.set_ylabel(ylabel) if ylabel
           backend.set_xlabel(xlabel) if xlabel

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/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

@@ -181,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
@@ -194,10 +199,58 @@ 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
         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)

data/lib/charty/vector.rb

@@ -51,6 +51,32 @@ module Charty
 
     def_delegators :adapter, :mean, :stdev
 
+    def_delegators :adapter, :scale, :scale_inverse
+
+    def scale(method)
+      case method
+      when :linear
+        self
+      when :log
+        adapter.log_scale(method)
+      else
+        raise ArgumentError,
+              "Invalid scaling method: %p" % method
+      end
+    end
+
+    def scale_inverse(method)
+      case method
+      when :linear
+        self
+      when :log
+        adapter.inverse_log_scale(method)
+      else
+        raise ArgumentError,
+              "Invalid scaling method: %p" % method
+      end
+    end
+
     # TODO: write test
     def categorical_order(order=nil)
       if order.nil?
@@ -59,7 +85,9 @@ module Charty
           order = categories
         else
           order = unique_values.compact
-          order.sort! if numeric?
+          if numeric?
+            order.sort_by! {|x| Util.missing?(x) ? Float::INFINITY : x }
+          end
         end
         order.compact!
       end

data/lib/charty/vector_adapters.rb

@@ -99,6 +99,22 @@ module Charty
       def stdev(population: false)
         Statistics.stdev(data, population: population)
       end
+
+      def log_scale(method)
+        Charty::Vector.new(
+          self.map {|x| Math.log10(x) },
+          index: index,
+          name: name
+        )
+      end
+
+      def inverse_log_scale(method)
+        Charty::Vector.new(
+          self.map {|x| 10.0 ** x },
+          index: index,
+          name: name
+        )
+      end
     end
 
     module NameSupport

data/lib/charty/vector_adapters/pandas_adapter.rb

@@ -152,7 +152,8 @@ module Charty
           group_keys = grouper.unique.to_a
           groups = data.groupby(grouper)
           group_keys.map {|g|
-            [g, Charty::Vector.new(groups.get_group(g))]
+            g_vals = groups.get_group(g) rescue []
+            [g, Charty::Vector.new(g_vals)]
           }.to_h
         when Charty::Vector
           case grouper.adapter
@@ -194,6 +195,14 @@ module Charty
         q = q.map {|x| x / 100.0 }
         data.quantile(q)
       end
+
+      def log_scale(method)
+        Charty::Vector.new(Numpy.log10(data))
+      end
+
+      def inverse_log_scale(method)
+        Charty::Vector.new(Numpy.power(10, data))
+      end
     end
   end
 end

data/lib/charty/version.rb

@@ -1,5 +1,5 @@
 module Charty
-  VERSION = "0.2.9"
+  VERSION = "0.2.10"
 
   module Version
     numbers, TAG = VERSION.split("-")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: charty
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.10
 platform: ruby
 authors:
 - youchan
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-06-24 00:00:00.000000000 Z
+date: 2021-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: red-colors
@@ -246,6 +246,8 @@ files:
 - charty.gemspec
 - examples/Gemfile
 - examples/active_record.ipynb
+- examples/bar_plot.rb
+- examples/box_plot.rb
 - examples/daru.ipynb
 - examples/iris_dataset.ipynb
 - examples/nmatrix.ipynb
@@ -284,6 +286,7 @@ files:
 - examples/sample_images/subplot_pyplot.png
 - examples/sample_pyplot.ipynb
 - examples/sample_rubyplot.ipynb
+- examples/scatter_plot.rb
 - images/design_concept.png
 - images/penguins_body_mass_g_flipper_length_mm_scatter_plot.png
 - images/penguins_body_mass_g_flipper_length_mm_species_scatter_plot.png
@@ -369,7 +372,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.23
 signing_key: 
 specification_version: 4
 summary: Visualizing your data in a simple way.