charty 0.2.1 → 0.2.7

data/lib/charty/plotter.rb

@@ -237,11 +237,11 @@ module Charty
     end
 
     def render(filename=nil)
-      @backend.render(self, filename)
+      @backend.old_style_render(self, filename)
     end
 
     def save(filename=nil, **kw)
-      @backend.save(self, filename, **kw)
+      @backend.old_style_save(self, filename, **kw)
     end
 
     def apply(backend)

data/lib/charty/plotters.rb

@@ -1,4 +1,15 @@
 require_relative "plotters/abstract_plotter"
+require_relative "plotters/random_support"
+require_relative "plotters/estimation_support"
 require_relative "plotters/categorical_plotter"
 require_relative "plotters/bar_plotter"
 require_relative "plotters/box_plotter"
+require_relative "plotters/count_plotter"
+
+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

@@ -8,44 +8,76 @@ module Charty
         self.data = data
         self.palette = palette
         substitute_options(options)
-        yield self if block_given?
-      end
 
-      attr_reader :x, :y, :color, :data, :palette
+        @var_levels = {}
+        @var_ordered = {x: false, y: false}
 
-      def x=(x)
-        @x = check_dimension(x, :x)
+        yield self if block_given?
       end
 
-      def y=(y)
-        @y = check_dimension(y, :y)
-      end
+      attr_reader :data, :x, :y, :color
+      attr_reader :color_order, :key_color, :palette
 
-      def color=(color)
-        # @color = check_dimension(color, :color)
-        unless color.nil?
-          raise NotImplementedError,
-                "Specifying color variable is not supported yet"
+      def var_levels
+        variables.each_key do |var|
+          # TODO: Move mappers from RelationalPlotter to here,
+          #       and remove the use of instance_variable_get
+          if instance_variable_defined?(:"@#{var}_mapper")
+            mapper = instance_variable_get(:"@#{var}_mapper")
+            @var_levels[var] = mapper.levels
+          end
         end
+        @var_levels
+      end
+
+      def inspect
+        "#<#{self.class}:0x%016x>" % self.object_id
       end
 
       def data=(data)
         @data = case data
                 when nil, Charty::Table
                   data
+                when method(:array?)
+                  Charty::Vector.new(data)
                 else
                   Charty::Table.new(data)
                 end
       end
 
+      def x=(x)
+        @x = check_dimension(x, :x)
+      end
+
+      def y=(y)
+        @y = check_dimension(y, :y)
+      end
+
+      def color=(color)
+        @color = check_dimension(color, :color)
+      end
+
+      def color_order=(color_order)
+        @color_order = color_order
+      end
+
+      # TODO: move to categorical_plotter
+      def key_color=(key_color)
+        #@key_color = XXX
+        unless key_color.nil?
+          raise NotImplementedError,
+                "Specifying key_color is not supported yet"
+        end
+      end
+
       def palette=(palette)
         @palette = case palette
-                   when nil, Charty::Palette, Symbol, String
+                   when nil, Palette, Symbol, String
                      palette
                    else
                      raise ArgumentError,
                        "invalid type for palette (given #{palette.class}, " +
-                       "expected Charty::Palette, Symbol, or String)"
+                       "expected Palette, Symbol, or String)"
                    end
       end
 
@@ -57,10 +89,12 @@ module Charty
 
       private def check_dimension(value, name)
         case value
-        when nil, Symbol, String, method(:array?)
+        when nil, Symbol, String
           value
         when ->(x) { x.respond_to?(:to_str) }
           value.to_str
+        when method(:array?)
+          Charty::Vector.new(value)
         else
           raise ArgumentError,
                 "invalid type of dimension for #{name} (given #{value.inspect})",
@@ -68,13 +102,149 @@ module Charty
         end
       end
 
+      private def check_number(value, name, allow_nil: false)
+        case value
+        when Numeric
+          value
+        else
+          if allow_nil && value.nil?
+            nil
+          else
+            expected = if allow_nil
+                         "number or nil"
+                       else
+                         "number"
+                       end
+            raise ArgumentError,
+                  "invalid value for #{name} (%p for #{expected})" % value,
+                  caller
+          end
+        end
+      end
+
+      private def check_boolean(value, name, allow_nil: false)
+        case value
+        when true, false
+          value
+        else
+          expected = if allow_nil
+                       "true, false, or nil"
+                     else
+                       "true or false"
+                     end
+          raise ArgumentError,
+                "invalid value for #{name} (%p for #{expected})" % value,
+                caller
+        end
+      end
+
+      private def variable_type(vector, boolean_type=:numeric)
+        if vector.numeric?
+          :numeric
+        elsif vector.categorical?
+          :categorical
+        else
+          case vector[0]
+          when true, false
+            boolean_type
+          else
+            :categorical
+          end
+        end
+      end
+
       private def array?(value)
         TableAdapters::HashAdapter.array?(value)
       end
 
+      private def remove_na!(ary)
+        ary.reject! {|x| Util.missing?(x) }
+        ary
+      end
+
+      private def each_subset(grouping_vars, reverse: false, processed: false, by_facet: true, allow_empty: false, drop_na: true)
+        case grouping_vars
+        when nil
+          grouping_vars = []
+        when String, Symbol
+          grouping_vars = [grouping_vars.to_sym]
+        end
+
+        if by_facet
+          [:col, :row].each do |facet_var|
+            grouping_vars << facet_var if variables.key?(facet_var)
+          end
+        end
+
+        grouping_vars = grouping_vars.select {|var| variables.key?(var) }
+
+        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|
+            next if group_data.empty? && !allow_empty
+
+            yield(grouping_vars.zip(group_key).to_h, group_data)
+          end
+        else
+          yield({}, data.dup)
+        end
+      end
+
+      def processed_data
+        @processed_data ||= calculate_processed_data
+      end
+
+      private def calculate_processed_data
+        # TODO: axis scaling support
+        plot_data
+      end
+
+      def save(filename, **kwargs)
+        backend = Backends.current
+        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)
+      end
+
+      private def render_plot(*, **)
+        raise NotImplementedError,
+              "subclass must implement #{__method__}"
+      end
+
       def to_iruby
-        result = render
-        ["text/html", result] if result
+        render(notebook: IRubyHelper.iruby_notebook?)
+      end
+
+      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

@@ -1,18 +1,200 @@
 module Charty
   module Plotters
     class BarPlotter < CategoricalPlotter
-      def render
-        backend = Backends.current
-        backend.begin_figure
+      self.default_palette = :light
+      self.require_numeric = true
+
+      def initialize(data: nil, variables: {}, **options, &block)
+        x, y, color = variables.values_at(:x, :y, :color)
+        super(x, y, color, data: data, **options, &block)
+      end
+
+      attr_reader :error_color
+
+      def error_color=(error_color)
+        @error_color = check_error_color(error_color)
+      end
+
+      private def check_error_color(value)
+        case value
+        when Colors::AbstractColor
+          value
+        when Array
+          Colors::RGB.new(*value)
+        when String
+          # TODO: Use Colors.parse when it'll be available
+          Colors::RGB.parse(value)
+        else
+          raise ArgumentError,
+                "invalid value for error_color (%p for a color, a RGB tripret, or a RGB hex string)" % value
+        end
+      end
+
+      attr_reader :error_width
+
+      def error_width=(error_width)
+        @error_width = check_number(error_width, :error_width, allow_nil: true)
+      end
+
+      attr_reader :cap_size
+
+      def cap_size=(cap_size)
+        @cap_size = check_number(cap_size, :cap_size, allow_nil: true)
+      end
+
+      private def render_plot(backend, **)
         draw_bars(backend)
         annotate_axes(backend)
-        backend.show
+        backend.invert_yaxis if orient == :h
       end
 
       private def draw_bars(backend)
-        statistic = @plot_data.map {|xs| Statistics.mean(xs) }
-        bar_pos = (0 ... statistic.length).to_a
-        backend.bar(bar_pos, statistic, color: @colors)
+        setup_estimations
+
+        if @plot_colors.nil?
+          bar_pos = (0 ... @estimations.length).to_a
+          error_colors = bar_pos.map { error_color }
+          if @conf_int.empty?
+            ci_params = {}
+          else
+            ci_params = {conf_int: @conf_int, error_colors: error_colors,
+                         error_width: error_width, cap_size: cap_size}
+          end
+          backend.bar(bar_pos, nil, @estimations, @colors, orient, **ci_params)
+        else
+          bar_pos = (0 ... @estimations[0].length).to_a
+          error_colors = bar_pos.map { error_color }
+          offsets = color_offsets
+          width = nested_width
+          @color_names.each_with_index do |color_name, i|
+            pos = bar_pos.map {|x| x + offsets[i] }
+            colors = Array.new(@estimations[i].length) { @colors[i] }
+            if @conf_int[i].empty?
+              ci_params = {}
+            else
+              ci_params = {conf_int: @conf_int[i], error_colors: error_colors,
+                           error_width: error_width, cap_size: cap_size}
+            end
+            backend.bar(pos, @group_names, @estimations[i], colors, orient,
+                        label: color_name, width: width, **ci_params)
+          end
+        end
+      end
+
+      private def setup_estimations
+        if @color_names.nil?
+          setup_estimations_with_single_color_group
+        else
+          setup_estimations_with_multiple_color_groups
+        end
+      end
+
+      private def setup_estimations_with_single_color_group
+        estimations = []
+        conf_int = []
+
+        @plot_data.each do |group_data|
+          # Single color group
+          if @plot_units.nil?
+            stat_data = group_data.drop_na
+            unit_data = nil
+          else
+            # TODO: Support units
+          end
+
+          estimation = if stat_data.size == 0
+                         Float::NAN
+                       else
+                         estimate(estimator, stat_data)
+                       end
+          estimations << estimation
+
+          unless ci.nil?
+            if stat_data.size < 2
+              conf_int << [Float::NAN, Float::NAN]
+              next
+            end
+
+            if ci == :sd
+              sd = stat_data.stdev
+              conf_int << [estimation - sd, estimation + sd]
+            else
+              conf_int << Statistics.bootstrap_ci(stat_data, ci, func: estimator, n_boot: n_boot,
+                                                  units: unit_data, random: random)
+            end
+          end
+        end
+
+        @estimations = estimations
+        @conf_int = conf_int
+      end
+
+      private def setup_estimations_with_multiple_color_groups
+        estimations = Array.new(@color_names.length) { [] }
+        conf_int = Array.new(@color_names.length) { [] }
+
+        @plot_data.each_with_index do |group_data, i|
+          @color_names.each_with_index do |color_name, j|
+            if @plot_colors[i].length == 0
+              estimations[j] << Float::NAN
+              unless ci.nil?
+                conf_int[j] << [Float::NAN, Float::NAN]
+              end
+              next
+            end
+
+            color_mask = @plot_colors[i].eq(color_name)
+            if @plot_units.nil?
+              begin
+              stat_data = group_data[color_mask].drop_na
+              rescue
+                @plot_data.each_with_index {|pd, k| p k => pd }
+                @plot_colors.each_with_index {|pc, k| p k => pc }
+                raise
+              end
+              unit_data = nil
+            else
+              # TODO: Support units
+            end
+
+            estimation = if stat_data.size == 0
+                           Float::NAN
+                         else
+                           estimate(estimator, stat_data)
+                         end
+            estimations[j] << estimation
+
+            unless ci.nil?
+              if stat_data.size < 2
+                conf_int[j] << [Float::NAN, Float::NAN]
+                next
+              end
+
+              if ci == :sd
+                sd = stat_data.stdev
+                conf_int[j] << [estimation - sd, estimation + sd]
+              else
+                conf_int[j] << Statistics.bootstrap_ci(stat_data, ci, func: estimator, n_boot: n_boot,
+                                                       units: unit_data, random: random)
+              end
+            end
+          end
+        end
+
+        @estimations = estimations
+        @conf_int = conf_int
+      end
+
+      private def estimate(estimator, data)
+        case estimator
+        when :count
+          data.length
+        when :mean
+          data.mean
+        else
+          # TODO: Support other estimations
+          raise NotImplementedError, "#{estimator} estimator is not supported yet"
+        end
       end
     end
   end