charty 0.2.3 → 0.2.4

data/lib/charty/plotters/bar_plotter.rb

@@ -1,18 +1,215 @@
 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
+
       def render
         backend = Backends.current
         backend.begin_figure
         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)
-        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

data/lib/charty/plotters/box_plotter.rb

@@ -1,25 +1,93 @@
 module Charty
   module Plotters
     class BoxPlotter < 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 :flier_size
+
+      def flier_size=(val)
+        @flier_size = check_number(val, :flier_size, allow_nil: true)
+      end
+
+      attr_reader :line_width
+
+      def line_width=(val)
+        @line_width = check_number(val, :line_width, allow_nil: true)
+      end
+
+      attr_reader :whisker
+
+      def whisker=(val)
+        @whisker = check_number(val, :whisker, allow_nil: true)
+      end
+
       def render
         backend = Backends.current
         backend.begin_figure
         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)
-        plot_data = @plot_data.each do |group_data|
-          next nil if group_data.empty?
+        if @plot_colors.nil?
+          plot_data = @plot_data.map do |group_data|
+            unless group_data.empty?
+              group_data = group_data.drop_na
+              group_data unless group_data.empty?
+            end
+          end
 
-          group_data = Array(group_data)
-          remove_na!(group_data)
+          backend.box_plot(plot_data,
+                           @group_names,
+                           orient: orient,
+                           colors: @colors,
+                           gray: @gray,
+                           dodge: dodge,
+                           width: @width,
+                           flier_size: flier_size,
+                           whisker: whisker)
+        else
+          grouped_box_data = @color_names.map.with_index do |color_name, i|
+            @plot_data.map.with_index do |group_data, j|
+              unless group_data.empty?
+                color_mask = @plot_colors[j].eq(color_name)
+                group_data = group_data[color_mask].drop_na
+                group_data unless group_data.empty?
+              end
+            end
+          end
 
-          group_data
+          backend.grouped_box_plot(grouped_box_data,
+                                   @group_names,
+                                   @color_names,
+                                   orient: orient,
+                                   colors: @colors,
+                                   gray: @gray,
+                                   dodge: dodge,
+                                   width: @width,
+                                   flier_size: flier_size,
+                                   whisker: whisker)
         end
-        backend.box_plot(plot_data, (0 ... @plot_data.length).to_a,
-                         color: @colors, gray: @gray)
       end
     end
   end

data/lib/charty/plotters/categorical_plotter.rb

@@ -1,7 +1,33 @@
 module Charty
   module Plotters
     class CategoricalPlotter < AbstractPlotter
-      def initialize(x, y, color, **options, &block)
+      class << self
+        attr_reader :default_palette
+
+        def default_palette=(val)
+          case val
+          when :light, :dark
+            @default_palette = val
+          when "light", "dark"
+            @default_palette = val.to_sym
+          else
+            raise ArgumentError, "default_palette must be :light or :dark"
+          end
+        end
+
+        attr_reader :require_numeric
+
+        def require_numeric=(val)
+          case val
+          when true, false
+            @require_numeric = val
+          else
+            raise ArgumentError, "require_numeric must be ture or false"
+          end
+        end
+      end
+
+      def initialize(x, y, color, order: nil, orient: nil, width: 0.8r, dodge: false, **options, &block)
         super
 
         setup_variables
@@ -11,9 +37,60 @@ module Charty
       attr_reader :order
 
       def order=(order)
-        @order = Array(order).map(&method(:normalize_name))
+        @order = order && Array(order).map(&method(:normalize_name))
+      end
+
+      attr_reader :orient
+
+      def orient=(orient)
+        @orient = check_orient(orient)
+      end
+
+      private def check_orient(value)
+        case value
+        when nil, :v, :h
+          value
+        when "v", "h"
+          value.to_sym
+        else
+          raise ArgumentError,
+                "invalid value for orient (#{value.inspect} for nil, :v, or :h)"
+        end
+      end
+
+      attr_reader :width
+
+      def width=(val)
+        @width = check_number(val, :width)
       end
 
+      attr_reader :dodge
+
+      def dodge=(dodge)
+        @dodge = check_boolean(dodge, :dodge)
+      end
+
+      attr_reader :saturation
+
+      def saturation=(saturation)
+        @saturation = check_saturation(saturation)
+      end
+
+      private def check_saturation(value)
+        case value
+        when 0..1
+          value
+        when Numeric
+          raise ArgumentError,
+                "saturation is out of range (%p for 0..1)" % value
+        else
+          raise ArgumentError,
+                "invalid value for saturation (%p for a value in 0..1)" % value
+        end
+      end
+
+      include EstimationSupport
+
       private def normalize_name(value)
         case value
         when String, Symbol
@@ -23,12 +100,16 @@ module Charty
         end
       end
 
-      attr_reader :group_names, :plot_data, :group_label, :value_label
+      attr_reader :group_names, :plot_data, :group_label
+
+      attr_accessor :value_label
 
       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
       end
@@ -62,36 +143,58 @@ module Charty
       end
 
       private def setup_variables_with_long_form_dataset
-        x, y = @x, @y
+        x = self.x
+        y = self.y
+        color = self.color
         if @data
-          x = @data[x] || x
-          y = @data[y] || y
+          x &&= @data[x] || x
+          y &&= @data[y] || y
+          color &&= @data[color] || color
         end
 
         # Validate inputs
-        [x, y].each do |input|
-          next if array?(input)
+        [x, y, color].each do |input|
+          next if input.nil? || array?(input)
           raise RuntimeError,
-                "Could not interpret interpret input `#{input.inspect}`"
+                "Could not interpret input `#{input.inspect}`"
         end
 
+        x = Charty::Vector.try_convert(x)
+        y = Charty::Vector.try_convert(y)
+        color = Charty::Vector.try_convert(color)
+
+        self.orient = infer_orient(x, y, orient, self.class.require_numeric)
+
         if x.nil? || y.nil?
           setup_single_data
         else
-          # FIXME: Assume vertical plot
-          groups, vals = x, y
+          if orient == :v
+            groups, vals = x, y
+          else
+            groups, vals = y, x
+          end
 
           if groups.respond_to?(:name)
             @group_label = groups.name
           end
 
-          if vals.respond_to?(:name)
-            @value_label = vals.name
+          @group_names = groups.categorical_order(order)
+          @plot_data, @value_label = group_long_form(vals, groups, @group_names)
+
+          # Handle color variable
+          if color.nil?
+            @plot_colors = nil
+            @color_title = nil
+            @color_names = nil
+          else
+            # Get the order of color levels
+            @color_names = color.categorical_order(color_order)
+
+            # Group the color data
+            @plot_colors, @color_title = group_long_form(color, groups, @group_names)
           end
 
-          # FIXME: Assume groups has only unique values
-          @group_names = groups
-          @plot_data = vals.map {|v| [v] }
+          # TODO: Handle units
         end
       end
 
@@ -100,48 +203,177 @@ module Charty
               "Single data plot is not supported yet"
       end
 
+      private def infer_orient(x, y, orient, require_numeric)
+        x_type = x.nil? ? nil : variable_type(x)
+        y_type = y.nil? ? nil : variable_type(y)
+
+        nonnumeric_error = "%{orient} orientation requires numeric `%{dim}` variable"
+        single_variable_warning = "%{orient} orientation ignored with only `%{dim}` specified"
+
+        case
+        when x.nil?
+          case orient
+          when :h
+            warn single_variable_warning % {orient: "Horizontal", dim: "y"}
+          end
+          if require_numeric && y_type != :numeric
+            raise ArgumentError, nonnumeric_error % {orient: "Vertical", dim: "y"}
+          end
+          return :v
+        when y.nil?
+          case orient
+          when :v
+            warn single_variable_warning % {orient: "Vertical", dim: "x"}
+          end
+          if require_numeric && x_type != :numeric
+            raise ArgumentError, nonnumeric_error % {orient: "Horizontal", dim: "x"}
+          end
+          return :h
+        end
+        case orient
+        when :v
+          if require_numeric && y_type != :numeric
+            raise ArgumentError, nonnumeric_error % {orient: "Vertical", dim: "y"}
+          end
+          return :v
+        when :h
+          if require_numeric && x_type != :numeric
+            raise ArgumentError, nonnumeric_error % {orient: "Horizontal", dim: "x"}
+          end
+          return :h
+        when nil
+          case
+          when x_type != :categorical && y_type == :categorical
+            return :h
+          when x_type != :numeric     && y_type == :numeric
+            return :v
+          when x_type == :numeric     && y_type != :numeric
+            return :h
+          when require_numeric && x_type != :numeric && y_type != :numeric
+            raise ArgumentError, "Neither the `x` nor `y` variable appears to be numeric."
+          else
+            :v
+          end
+        else
+          # must be unreachable
+          raise RuntimeError, "BUG in Charty. Please report the issue."
+        end
+      end
+
+      private def group_long_form(vals, groups, group_order)
+        grouped_vals = vals.group_by(groups)
+
+        plot_data = group_order.map {|g| grouped_vals[g] || [] }
+
+        if vals.respond_to?(:name)
+          value_label = vals.name
+        end
+
+        return plot_data, value_label
+      end
+
       private def setup_colors
-        n_colors = @plot_data.length
-        if @palette.nil?
+        if @color_names.nil?
+          n_colors = @plot_data.length
+        else
+          n_colors = @color_names.length
+        end
+
+        if key_color.nil? && self.palette.nil?
+          # Check the current palette has enough colors
           current_palette = Palette.default
           if n_colors <= current_palette.n_colors
-            palette = Palette.new(current_palette.colors, n_colors)
+            colors = Palette.new(current_palette.colors, n_colors).colors
+          else
+            # Use huls palette as default when the default palette is not usable
+            colors = Palette.husl_colors(n_colors, l: 0.7r)
+          end
+        elsif self.palette.nil?
+          if @color_names.nil?
+            colors = Array.new(n_colors) { key_color }
           else
-            palette = Palette.husl(n_colors, l: 0.7r)
+            raise NotImplementedError,
+                  "Default palette with key_color is not supported"
+            # TODO: Support light_palette and dark_palette in red-palette
+            # if default_palette is light
+            #   colors = Palette.light_palette(key_color, n_colors)
+            # elsif default_palette is dark
+            #   colors = Palette.dark_palette(key_color, n_colors)
+            # else
+            #   raise "No default palette specified"
+            # end
           end
         else
-          case @palette
+          case self.palette
           when Hash
-            # Assume @palette has a hash table that maps
-            # group_names to colors
-            palette = @group_names.map {|gn| @palette[gn] }
-          else
-            palette = @palette
+            if @color_names.nil?
+              levels = @group_names
+            else
+              levels = @color_names
+            end
+            colors = levels.map {|gn| self.palette[gn] }
           end
-          palette = Palette.new(palette, n_colors)
+          colors = Palette.new(colors, n_colors).colors
+        end
+
+        if saturation < 1
+          colors = Palette.new(colors, n_colors, desaturate_factor: saturation).colors
         end
 
-        @colors = palette.colors.map {|c| c.to_rgb }
+        @colors = colors.map {|c| c.to_rgb }
         lightness_values = @colors.map {|c| c.to_hsl.l }
         lum = lightness_values.min * 0.6r
         @gray = Colors::RGB.new(lum, lum, lum)  # TODO: Use Charty::Gray
       end
 
-      private def annotate_axes(backend)
-        backend.set_xlabel(@group_label)
-        backend.set_ylabel(@value_label)
-        backend.set_xticks((0 ... @plot_data.length).to_a)
-        backend.set_xtick_labels(@group_names)
-        backend.disable_xaxis_grid
-        backend.set_xlim(-0.5, @plot_data.length - 0.5)
+      private def color_offsets
+        n_names = @color_names.length
+        if self.dodge
+          each_width = @width / n_names
+          offsets = Charty::Linspace.new(0 .. (@width - each_width), n_names).to_a
+          offsets_mean = Statistics.mean(offsets)
+          offsets.map {|x| x - offsets_mean }
+        else
+          Array.new(n_names) { 0 }
+        end
       end
 
-      private def remove_na!(ary)
-        ary.reject! do |x|
-          next true if x.nil?
-          x.respond_to?(:nan?) && x.nan?
+      private def nested_width
+        if self.dodge
+          @width / @color_names.length * 0.98r
+        else
+          @width
+        end
+      end
+
+      private def annotate_axes(backend)
+        if orient == :v
+          xlabel, ylabel = @group_label, @value_label
+        else
+          xlabel, ylabel = @value_label, @group_label
+        end
+        backend.set_xlabel(xlabel) unless xlabel.nil?
+        backend.set_ylabel(ylabel) unless ylabel.nil?
+
+        if orient == :v
+          backend.set_xticks((0 ... @plot_data.length).to_a)
+          backend.set_xtick_labels(@group_names)
+        else
+          backend.set_yticks((0 ... @plot_data.length).to_a)
+          backend.set_ytick_labels(@group_names)
+        end
+
+        if orient == :v
+          backend.disable_xaxis_grid
+          backend.set_xlim(-0.5, @plot_data.length - 0.5)
+        else
+          backend.disable_yaxis_grid
+          backend.set_ylim(-0.5, @plot_data.length - 0.5)
+        end
+
+        unless @color_names.nil?
+          backend.legend(loc: :best, title: @color_title)
         end
-        ary
       end
     end
   end