charty 0.2.6 → 0.2.10

data/lib/charty/plotters.rb

@@ -10,3 +10,6 @@ require_relative "plotters/vector_plotter"
 require_relative "plotters/relational_plotter"
 require_relative "plotters/scatter_plotter"
 require_relative "plotters/line_plotter"
+
+require_relative "plotters/distribution_plotter"
+require_relative "plotters/histogram_plotter"

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].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|
@@ -213,16 +245,19 @@ module Charty
 
       def save(filename, **kwargs)
         backend = Backends.current
-        backend.begin_figure
-        render_plot(backend, **kwargs)
+        call_render_plot(backend, notebook: false, **kwargs)
         backend.save(filename, **kwargs)
       end
 
       def render(notebook: false, **kwargs)
         backend = Backends.current
+        call_render_plot(backend, notebook: notebook, **kwargs)
+        backend.render(notebook: notebook, **kwargs)
+      end
+
+      private def call_render_plot(backend, notebook: false, **kwargs)
         backend.begin_figure
         render_plot(backend, notebook: notebook, **kwargs)
-        backend.render(notebook: notebook, **kwargs)
       end
 
       private def render_plot(*, **)
@@ -231,12 +266,17 @@ module Charty
       end
 
       def to_iruby
-        render(notebook: iruby_notebook?)
+        render(notebook: IRubyHelper.iruby_notebook?)
       end
 
-      private def iruby_notebook?
-        return false unless defined?(IRuby)
-        true # TODO: Check the server is notebook or not
+      def to_iruby_mimebundle(include: [], exclude: [])
+        backend = Backends.current
+        if backend.respond_to?(:render_mimebundle)
+          call_render_plot(backend, notebook: true)
+          backend.render_mimebundle(include: include, exclude: exclude)
+        else
+          {}
+        end
       end
     end
   end

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

@@ -0,0 +1,180 @@
+module Charty
+  module Plotters
+    class DistributionPlotter < AbstractPlotter
+      def flat_structure
+        {
+          x: :@values
+        }
+      end
+
+      def wide_structure
+        {
+          x: :@values,
+          color: :@columns
+        }
+      end
+
+      def initialize(data:, variables:, **options, &block)
+        x, y, color = variables.values_at(:x, :y, :color)
+        super(x, y, color, data: data, **options, &block)
+
+        setup_variables
+      end
+
+      attr_reader :weights
+
+      def weights=(val)
+        @weights = check_dimension(val, :weights)
+      end
+
+      attr_reader :variables
+
+      attr_reader :color_norm
+
+      def color_norm=(val)
+        unless val.nil?
+          raise NotImplementedError,
+                "Specifying color_norm is not supported yet"
+        end
+      end
+
+      attr_reader :legend
+
+      def legend=(val)
+        @legend = check_legend(val)
+      end
+
+      private def check_legend(val)
+        check_boolean(val, :legend)
+      end
+
+      attr_reader :input_format, :plot_data, :variables, :var_types
+
+      # This should be the same as one in RelationalPlotter
+      # TODO: move this to AbstractPlotter and refactor with CategoricalPlotter
+      private def setup_variables
+        if x.nil? && y.nil?
+          @input_format = :wide
+          setup_variables_with_wide_form_dataset
+        else
+          @input_format = :long
+          setup_variables_with_long_form_dataset
+        end
+
+        @var_types = @plot_data.columns.map { |k|
+          [k, variable_type(@plot_data[k], :categorical)]
+        }.to_h
+      end
+
+      private def setup_variables_with_wide_form_dataset
+        unless color.nil?
+          raise ArgumentError,
+                "Unable to assign the following variables in wide-form data: color"
+        end
+
+        if data.nil? || data.empty?
+          @plot_data = Charty::Table.new({})
+          @variables = {}
+          return
+        end
+
+        flat = data.is_a?(Charty::Vector)
+        if flat
+          @plot_data = {}
+          @variables = {}
+
+          [:x, :y].each do |var|
+            case self.flat_structure[var]
+            when :@index
+              @plot_data[var] = data.index.to_a
+              @variables[var] = data.index.name
+            when :@values
+              @plot_data[var] = data.to_a
+              @variables[var] = data.name
+            end
+          end
+
+          @plot_data = Charty::Table.new(@plot_data)
+        else
+          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
+
+      private def setup_variables_with_long_form_dataset
+        if data.nil? || data.empty?
+          @plot_data = Charty::Table.new({})
+          @variables = {}
+          return
+        end
+
+        plot_data = {}
+        variables = {}
+
+        {
+          x: self.x,
+          y: self.y,
+          color: self.color,
+          weights: self.weights
+        }.each do |key, val|
+          next if val.nil?
+
+          if data.column?(val)
+            plot_data[key] = data[val]
+            variables[key] = val
+          else
+            case val
+            when Charty::Vector
+              plot_data[key] = val
+              variables[key] = val.name
+            else
+              raise ArgumentError,
+                    "Could not interpret value %p for parameter %p" % [val, key]
+            end
+          end
+        end
+
+        @plot_data = Charty::Table.new(plot_data)
+        @variables = variables.select do |var, name|
+          @plot_data[var].notnull.any?
+        end
+      end
+
+      private def map_color(palette: nil, order: nil, norm: nil)
+        @color_mapper = ColorMapper.new(self, palette, order, norm)
+      end
+
+      private def map_size(sizes: nil, order: nil, norm: nil)
+        @size_mapper = SizeMapper.new(self, sizes, order, norm)
+      end
+
+      private def map_style(markers: nil, dashes: nil, order: nil)
+        @style_mapper = StyleMapper.new(self, markers, dashes, order)
+      end
+    end
+  end
+end

data/lib/charty/plotters/histogram_plotter.rb

@@ -0,0 +1,244 @@
+module Charty
+  module Plotters
+    class HistogramPlotter < DistributionPlotter
+      def univariate?
+        self.variables.key?(:x) != self.variables.key?(:y)
+      end
+
+      def univariate_variable
+        unless univariate?
+          raise TypeError, "This is not a univariate plot"
+        end
+        ([:x, :y] & self.variables.keys)[0]
+      end
+
+      attr_reader :stat
+
+      def stat=(val)
+        @stat = check_stat(val)
+      end
+
+      private def check_stat(val)
+        case val
+        when :count, "count"
+          val.to_sym
+        when :frequency, "frequency",
+             :density, "density",
+             :probability, "probability"
+          raise ArgumentError,
+                "%p for `stat` is not supported yet" % val,
+                caller
+        else
+          raise ArgumentError,
+                "Invalid value for `stat` (%p)" % val,
+                caller
+        end
+      end
+
+      attr_reader :bins
+
+      def bins=(val)
+        @bins = check_bins(val)
+      end
+
+      private def check_bins(val)
+        case val
+        when :auto, "auto"
+          val.to_sym
+        when Integer
+          val
+        else
+          raise ArgumentError,
+                "Invalid value for `bins` (%p)" % val,
+                caller
+        end
+      end
+
+      # TODO: bin_width
+
+      attr_reader :bin_range
+
+      def bin_range=(val)
+        @bin_range = check_bin_range(val)
+      end
+
+      private def check_bin_range(val)
+        case val
+        when nil, Range
+          return val
+        when Array
+          if val.length == 2
+            val.each_with_index do |v, i|
+              check_number(v, "bin_range[#{i}]")
+            end
+            return val
+          else
+            amount = val.length < 2 ? "few" : "many"
+            raise ArgumentError,
+                  "Too #{amount} items in `bin_range` array (%p for 2)" % val.length
+          end
+        else
+          raise ArgumentError,
+                "Invalid value for `bin_range` " +
+                "(%p for a range or a pair of numbers)" % val
+        end
+      end
+
+      # TODO: discrete
+      # TODO: cumulative
+
+      attr_reader :common_bins
+
+      def common_bins=(val)
+        @common_bins = check_boolean(val, :common_bins)
+      end
+
+      # TODO: common_norm
+
+      attr_reader :multiple
+
+      def multiple=(val)
+        @multiple = check_multiple(val)
+      end
+
+      private def check_multiple(val)
+        case val
+        when :layer, "layer"
+          val.to_sym
+        when :dodge, "dodge",
+             :stack, "stack",
+             :fill, "fill"
+          val = val.to_sym
+          raise NotImplementedError,
+                "%p for `multiple` is not supported yet" % val,
+                caller
+        else
+          raise ArgumentError,
+                "Invalid value for `multiple` (%p)" % val,
+                caller
+        end
+      end
+
+      # TODO: element
+      # TODO: fill
+      # TODO: shrink
+
+      attr_reader :kde
+
+      def kde=(val)
+        raise NotImplementedError, "kde is not supported yet"
+      end
+
+      attr_reader :kde_params
+
+      def kde_params=(val)
+        raise NotImplementedError, "kde_params is not supported yet"
+      end
+
+      # TODO: thresh
+      # TODO: pthresh
+      # TODO: pmax
+      # TODO: cbar
+      # TODO: cbar_params
+      # TODO: x_log_scale
+      # TODO: y_log_scale
+
+      private def render_plot(backend, **)
+        draw_univariate_histogram(backend)
+        annotate_axes(backend)
+      end
+
+      private def draw_univariate_histogram(backend)
+        map_color(palette: palette, order: color_order, norm: color_norm)
+
+        key_color = self.key_color
+        if key_color.nil? && !self.variables.key?(:color)
+          palette = case self.palette
+                    when Palette
+                      self.palette
+                    when nil
+                      Palette.default
+                    else
+                      Palette[self.palette]
+                    end
+          key_color = palette[0]
+        end
+
+        # TODO: calculate histogram here and use bar plot to visualize
+        data_variable = self.univariate_variable
+
+        if common_bins
+          all_data = processed_data.drop_na
+          all_observations = all_data[data_variable].to_a
+
+          bins = self.bins
+          bins = 10 if self.variables.key?(:color) && bins == :auto
+
+          case bins
+          when Integer
+            case bin_range
+            when Range
+              start = bin_range.begin
+              stop  = bin_range.end
+            when Array
+              start, stop = bin_range.minmax
+            end
+            data_range = all_observations.minmax
+            start ||= data_range[0]
+            stop ||= data_range[1]
+            if start == stop
+              start -= 0.5
+              stop += 0.5
+            end
+            common_bin_edges = Linspace.new(start .. stop, bins + 1).map(&:to_f)
+          else
+            params = {}
+            params[:weights] = all_data[:weights].to_a if all_data.column?(:weights)
+            h = Statistics.histogram(all_observations, bins, **params)
+            common_bin_edges = h.edges
+          end
+        end
+
+        if self.variables.key?(:color)
+          alpha = 0.5
+        else
+          alpha = 0.75
+        end
+
+        each_subset([:color], processed: true) do |sub_vars, sub_data|
+          observations = sub_data[data_variable].drop_na.to_a
+          params = {}
+          params[:weights] = sub_data[:weights].to_a if sub_data.column?(:weights)
+          params[:edges] = common_bin_edges if common_bin_edges
+          hist = Statistics.histogram(observations, bins, **params)
+
+          name = sub_vars[:color]
+          backend.univariate_histogram(hist, name, data_variable, stat,
+                                       alpha, name, key_color, @color_mapper,
+                                       multiple, :bars, true, 1r)
+        end
+      end
+
+      private def annotate_axes(backend)
+        backend.set_title(self.title) if self.title
+
+        if univariate?
+          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
+          else
+            xlabel ||= self.stat.to_s.capitalize
+          end
+          backend.set_ylabel(ylabel) if ylabel
+          backend.set_xlabel(xlabel) if xlabel
+
+          if self.variables.key?(:color)
+            backend.legend(loc: :best, title: self.variables[:color])
+          end
+        end
+      end
+    end
+  end
+end