charty 0.2.1 → 0.2.7

data/lib/charty/plotters/box_plotter.rb

@@ -1,25 +1,78 @@
 module Charty
   module Plotters
     class BoxPlotter < 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 :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
+
+      private def render_plot(backend, **)
         draw_box_plot(backend)
         annotate_axes(backend)
-        backend.show
+        backend.invert_yaxis if orient == :h
       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