charty 0.2.0 → 0.2.6

data/lib/charty/plotter.rb

@@ -237,22 +237,22 @@ module Charty
     end
 
     def render(filename=nil)
-      @backend.render(self, filename)
+      @backend.old_style_render(self, filename)
     end
 
-    def save(filename=nil)
-      @backend.save(self, filename)
+    def save(filename=nil, **kw)
+      @backend.old_style_save(self, filename, **kw)
     end
 
     def apply(backend)
       case
-        when !@series.empty?
-          backend.series = @series
-        when @function
-          linspace = Linspace.new(@range[:x], 100)
-          # TODO: set label with function
-          # TODO: set ys to xs when gruff curve with function
-          @series << Series.new(linspace.to_a, linspace.map{|x| @function.call(x) }, label: "function" )
+      when !@series.empty?
+        backend.series = @series
+      when @function
+        linspace = Linspace.new(@range[:x], 100)
+        # TODO: set label with function
+        # TODO: set ys to xs when gruff curve with function
+        @series << Series.new(linspace.to_a, linspace.map{|x| @function.call(x) }, label: "function" )
       end
 
       @backend = backend

data/lib/charty/plotters.rb

@@ -0,0 +1,12 @@
+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"

data/lib/charty/plotters/abstract_plotter.rb

@@ -0,0 +1,243 @@
+module Charty
+  module Plotters
+    class AbstractPlotter
+      def initialize(x, y, color, **options)
+        self.x = x
+        self.y = y
+        self.color = color
+        self.data = data
+        self.palette = palette
+        substitute_options(options)
+
+        @var_levels = {}
+        @var_ordered = {x: false, y: false}
+
+        yield self if block_given?
+      end
+
+      attr_reader :data, :x, :y, :color
+      attr_reader :color_order, :key_color, :palette
+
+      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, Palette, Symbol, String
+                     palette
+                   else
+                     raise ArgumentError,
+                       "invalid type for palette (given #{palette.class}, " +
+                       "expected Palette, Symbol, or String)"
+                   end
+      end
+
+      private def substitute_options(options)
+        options.each do |key, val|
+          send("#{key}=", val)
+        end
+      end
+
+      private def check_dimension(value, name)
+        case value
+        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})",
+                caller
+        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].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
+        backend.begin_figure
+        render_plot(backend, **kwargs)
+        backend.save(filename, **kwargs)
+      end
+
+      def render(notebook: false, **kwargs)
+        backend = Backends.current
+        backend.begin_figure
+        render_plot(backend, notebook: notebook, **kwargs)
+        backend.render(notebook: notebook, **kwargs)
+      end
+
+      private def render_plot(*, **)
+        raise NotImplementedError,
+              "subclass must implement #{__method__}"
+      end
+
+      def to_iruby
+        render(notebook: iruby_notebook?)
+      end
+
+      private def iruby_notebook?
+        return false unless defined?(IRuby)
+        true # TODO: Check the server is notebook or not
+      end
+    end
+  end
+end

data/lib/charty/plotters/bar_plotter.rb

@@ -0,0 +1,201 @@
+module Charty
+  module Plotters
+    class BarPlotter < CategoricalPlotter
+      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.invert_yaxis if orient == :h
+      end
+
+      private def draw_bars(backend)
+        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
+end