charty 0.2.4 → 0.2.9

data/lib/charty/plotters/bar_plotter.rb

@@ -42,25 +42,10 @@ module Charty
         @cap_size = check_number(cap_size, :cap_size, allow_nil: true)
       end
 
-      def render
-        backend = Backends.current
-        backend.begin_figure
+      private def render_plot(backend, **)
         draw_bars(backend)
         annotate_axes(backend)
         backend.invert_yaxis if orient == :h
-        backend.show
-      end
-
-      # TODO:
-      # - Should infer mime type from file's extname
-      # - Should check backend's supported mime type before begin_figure
-      def save(filename, **opts)
-        backend = Backends.current
-        backend.begin_figure
-        draw_bars(backend)
-        annotate_axes(backend)
-        backend.invert_yaxis if orient == :h
-        backend.save(filename, **opts)
       end
 
       private def draw_bars(backend)

data/lib/charty/plotters/box_plotter.rb

@@ -27,25 +27,10 @@ module Charty
         @whisker = check_number(val, :whisker, allow_nil: true)
       end
 
-      def render
-        backend = Backends.current
-        backend.begin_figure
+      private def render_plot(backend, **)
         draw_box_plot(backend)
         annotate_axes(backend)
         backend.invert_yaxis if orient == :h
-        backend.show
-      end
-
-      # TODO:
-      # - Should infer mime type from file's extname
-      # - Should check backend's supported mime type before begin_figure
-      def save(filename, **opts)
-        backend = Backends.current
-        backend.begin_figure
-        draw_box_plot(backend)
-        annotate_axes(backend)
-        backend.invert_yaxis if orient == :h
-        backend.save(filename, **opts)
       end
 
       private def draw_box_plot(backend)

data/lib/charty/plotters/distribution_plotter.rb

@@ -0,0 +1,150 @@
+module Charty
+  module Plotters
+    class DistributionPlotter < AbstractPlotter
+      def flat_structure
+        {
+          x: :values
+        }
+      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
+
+        # TODO: detect flat data
+        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
+          raise NotImplementedError,
+                "wide-form input is not supported"
+        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,242 @@
+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)
+        if univariate?
+          xlabel = self.variables[:x]
+          ylabel = 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

data/lib/charty/plotters/line_plotter.rb

@@ -0,0 +1,300 @@
+module Charty
+  module Plotters
+    class EstimateAggregator
+      def initialize(estimator, error_bar, n_boot, random)
+        @estimator = estimator
+        @method, @level = error_bar
+        @n_boot = n_boot
+        @random = random
+      end
+
+      # Perform aggregation
+      #
+      # @param data [Hash<Any, Charty::Table>]
+      # @param var_name [Symbol, String]  A column name to be aggregated
+      def aggregate(data, var_name)
+        values = data[var_name]
+        estimation = case @estimator
+                     when :count
+                       values.length
+                     when :mean
+                       values.mean
+                     end
+
+        n = values.length
+        case
+        # No error bars
+        when @method.nil?
+          err_min = err_max = Float::NAN
+        when n <= 1
+          err_min = err_max = Float::NAN
+
+        # User-defined method
+        when @method.respond_to?(:call)
+          err_min, err_max = @method.call(values)
+
+        # Parametric
+        when @method == :sd
+          err_radius = values.stdev * @level
+          err_min = estimation - err_radius
+          err_max = estimation + err_radius
+        when @method == :se
+          err_radius = values.stdev / Math.sqrt(n)
+          err_min = estimation - err_radius
+          err_max = estimation + err_radius
+
+        # Nonparametric
+        when @method == :pi
+          err_min, err_max = percentile_interval(values, @level)
+        when @method == :ci
+          # TODO: Support units
+          err_min, err_max =
+            Statistics.bootstrap_ci(values, @level, units: nil, func: @estimator,
+                                    n_boot: @n_boot, random: @random)
+        end
+
+        {
+          var_name => estimation,
+          "#{var_name}_min" => err_min,
+          "#{var_name}_max" => err_max
+        }
+      end
+
+      def percentile_interval(values, width)
+        q = [50 - width / 2, 50 + width / 2]
+        Statistics.percentile(values, q)
+      end
+    end
+
+    class LinePlotter < RelationalPlotter
+      def initialize(data: nil, variables: {}, **options, &block)
+        x, y, color, style, size = variables.values_at(:x, :y, :color, :style, :size)
+        super(x, y, color, style, size, data: data, **options, &block)
+
+        @comp_data = nil
+      end
+
+      attr_reader :estimator
+
+      def estimator=(estimator)
+        @estimator = check_estimator(estimator)
+      end
+
+      private def check_estimator(value)
+        case value
+        when nil, false
+          nil
+        when :count, "count"
+          :count
+        when :mean, "mean"
+          :mean
+        when :median
+          raise NotImplementedError,
+                "median estimator has not been supported yet"
+        when Proc
+          raise NotImplementedError,
+                "a callable estimator has not been supported yet"
+        else
+          raise ArgumentError,
+                "invalid value for estimator (%p for :mean)" % value
+        end
+      end
+
+      attr_reader :n_boot
+
+      def n_boot=(n_boot)
+        @n_boot = check_n_boot(n_boot)
+      end
+
+      private def check_n_boot(value)
+        case value
+        when Integer
+          if value <= 0
+            raise ArgumentError,
+                  "n_boot must be larger than zero, but %p is given" % value
+          end
+          value
+        else
+          raise ArgumentError,
+                "invalid value for n_boot (%p for an integer > 0)" % value
+        end
+      end
+
+      include RandomSupport
+
+      attr_reader :sort, :err_style, :err_kws, :error_bar, :x_scale, :y_scale
+
+      def sort=(val)
+        @sort = check_boolean(val, :sort)
+      end
+
+      def err_style=(val)
+        @err_style = check_err_style(val)
+      end
+
+      private def check_err_style(val)
+        case val
+        when :bars, "bars", :band, "band"
+          val.to_sym
+        else
+          raise ArgumentError,
+                "Invalid value for err_style (%p for :band or :bars)" % val
+        end
+      end
+
+      # parameters to draw error bars/bands
+      def err_params=(val)
+        unless val.nil?
+          raise NotImplementedError,
+                "Specifying `err_params` is not supported"
+        end
+      end
+
+      # The method and level to calculate error bars/bands
+      def error_bar=(val)
+        @error_bar = check_error_bar(val)
+      end
+
+      DEFAULT_ERROR_BAR_LEVELS = {
+        ci: 95,
+        pi: 95,
+        se: 1,
+        sd: 1
+      }.freeze
+
+      VALID_ERROR_BAR_METHODS = DEFAULT_ERROR_BAR_LEVELS.keys
+      VALID_ERROR_BAR_METHODS.concat(VALID_ERROR_BAR_METHODS.map(&:to_s))
+      VALID_ERROR_BAR_METHODS.freeze
+
+      private def check_error_bar(val)
+        case val
+        when nil
+          return [nil, nil]
+        when ->(x) { x.respond_to?(:call) }
+          return [val, nil]
+        when *VALID_ERROR_BAR_METHODS
+          method = val.to_sym
+          level = nil
+        when Array
+          if val.length != 2
+            raise ArgumentError,
+                  "The `error_bar` array has the wrong number of items " +
+                  "(%d for 2)" % val.length
+          end
+          method, level = *val
+        else
+          raise ArgumentError,
+                "Unable to recognize the value for `error_bar`: %p" % val
+        end
+
+        case method
+        when *VALID_ERROR_BAR_METHODS
+          method = method.to_sym
+        else
+          error_message = "The value for method in `error_bar` array must be in %p, but %p was passed" % [
+            DEFAULT_ERROR_BAR_LEVELS.keys,
+            method
+          ]
+          raise ArgumentError, error_message
+        end
+
+        case level
+        when Numeric
+          # nothing to do
+        when nil
+          level = DEFAULT_ERROR_BAR_LEVELS[method]
+        else
+          raise ArgumentError,
+                "The value of level in `error_bar` array must be a number "
+        end
+
+        [method, level]
+      end
+
+      def x_scale=(val)
+        @x_scale = check_axis_scale(val, :x)
+      end
+
+      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"
+          val.to_sym
+        else
+          raise ArgumentError,
+                "The value of `#{axis}_scale` is worng: %p" % val,
+                caller
+        end
+      end
+
+      private def render_plot(backend, **)
+        draw_lines(backend)
+        annotate_axes(backend)
+      end
+
+      private def draw_lines(backend)
+        map_color(palette: palette, order: color_order, norm: color_norm)
+        map_size(sizes: sizes, order: size_order, norm: size_norm)
+        map_style(markers: markers, dashes: dashes, order: style_order)
+
+        aggregator = EstimateAggregator.new(estimator, error_bar, n_boot, random)
+
+        agg_var = :y
+        grouper = :x
+        grouping_vars = [:color, :size, :style]
+
+        each_subset(grouping_vars, processed: true) do |sub_vars, sub_data|
+          if self.sort
+            sort_cols = [:units, :x, :y] & self.variables.keys
+            sub_data = sub_data.sort_values(sort_cols)
+          end
+
+          unless estimator.nil?
+            if self.variables.include?(:units)
+              raise "`estimator` is must be nil when specifying `units`"
+            end
+
+            grouped = sub_data.group_by(grouper, sort: self.sort)
+            sub_data = grouped.apply(agg_var, &aggregator.method(:aggregate)).reset_index
+          end
+
+          # TODO: perform inverse conversion of axis scaling before plot
+
+          unit_grouping = if self.variables.include?(:units)
+                            sub_data.group_by(:units).each_group
+                          else
+                            { nil => sub_data }
+                          end
+          unit_grouping.each do |_unit_value, unit_data|
+            ci_params = unless self.estimator.nil? || self.error_bar.nil?
+                          {
+                            style: self.err_style,
+                            y_min: sub_data[:y_min],
+                            y_max: sub_data[:y_max]
+                          }
+                        end
+            backend.line(unit_data[:x], unit_data[:y], self.variables,
+                         color: sub_vars[:color], color_mapper: @color_mapper,
+                         size: sub_vars[:size], size_mapper: @size_mapper,
+                         style: sub_vars[:style], style_mapper: @style_mapper,
+                         ci_params: ci_params)
+          end
+        end
+
+        if legend
+          backend.add_line_plot_legend(@variables, @color_mapper, @size_mapper, @style_mapper, legend)
+        end
+      end
+
+      private def annotate_axes(backend)
+        xlabel = self.variables[:x]
+        ylabel = self.variables[:y]
+        backend.set_xlabel(xlabel) unless xlabel.nil?
+        backend.set_ylabel(ylabel) unless ylabel.nil?
+      end
+    end
+  end
+end