charty 0.1.4.dev → 0.2.4

data/lib/charty/plotters.rb

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

data/lib/charty/plotters/abstract_plotter.rb

@@ -0,0 +1,156 @@
+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)
+        yield self if block_given?
+      end
+
+      attr_reader :data, :x, :y, :color
+      attr_reader :color_order, :key_color, :palette
+
+      def data=(data)
+        @data = case data
+                when nil, Charty::Table
+                  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 = XXX
+        unless color_order.nil?
+          raise NotImplementedError,
+                "Specifying color_order is not supported yet"
+        end
+      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! do |x|
+          next true if x.nil?
+          x.respond_to?(:nan?) && x.nan?
+        end
+        ary
+      end
+
+      def to_iruby
+        result = render
+        ["text/html", result] if result
+      end
+    end
+  end
+end

data/lib/charty/plotters/bar_plotter.rb

@@ -0,0 +1,216 @@
+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)
+        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

data/lib/charty/plotters/box_plotter.rb

@@ -0,0 +1,94 @@
+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)
+        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
+
+          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
+
+          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
+      end
+    end
+  end
+end