charty 0.2.5 → 0.2.6

data/lib/charty/dash_pattern_generator.rb

@@ -0,0 +1,57 @@
+module Charty
+  module DashPatternGenerator
+    NAMED_PATTERNS = {
+            solid: "",
+             dash: [4, 1.5],
+              dot:  [1, 1],
+          dashdot: [3, 1.25, 1.5, 1.25],
+      longdashdot: [5, 1, 1, 1],
+    }.freeze
+
+    def self.valid_name?(name)
+      name = case name
+             when Symbol, String
+               name.to_sym
+             else
+               name.to_str.to_sym
+             end
+      NAMED_PATTERNS.key?(name)
+    end
+
+    def self.pattern_to_name(pattern)
+      NAMED_PATTERNS.each do |key, val|
+        return key if pattern == val
+      end
+      nil
+    end
+
+    def self.each
+      return enum_for(__method__) unless block_given?
+
+      NAMED_PATTERNS.each_value do |pattern|
+        yield pattern
+      end
+
+      m = 3
+      while true
+        # Long and short dash combinations
+        a = [3, 1.25].repeated_combination(m).to_a[1..-2].reverse
+        b = [4, 1].repeated_combination(m).to_a[1..-2]
+
+        # Interleave these combinations
+        segment_list = a.zip(b).flatten(1)
+
+        # Insert the gaps
+        segment_list.each do |segment|
+          gap = segment.min
+          pattern = segment.map {|seg| [seg, gap] }.flatten
+          yield pattern
+        end
+
+        m += 1
+      end
+    end
+
+    extend Enumerable
+  end
+end

data/lib/charty/index.rb

@@ -49,7 +49,7 @@ module Charty
         return index.union(other) if index
       end
 
-      Index.new(to_a.union(other.to_a))
+      Index.new(to_a.union(other.to_a), name: name)
     end
   end
 

data/lib/charty/plot_methods.rb

@@ -130,6 +130,76 @@ module Charty
       )
     end
 
+    # Line plot
+    #
+    # @param x [vector-like object, key in data]
+    # @param y [vector-like object, key in data]
+    # @param color [vector-like object, key in data]
+    # @param style [vector-like object, key in data]
+    # @param size [vector-like object, key in data]
+    # @param data [table-like object]
+    # @param key_color [color object]
+    # @param palette [String,Array<Numeric>,Palette]
+    # @param color_order [Array<String>,Array<Symbol>]
+    # @param color_norm
+    # @param sizes [Array, Hash]
+    # @param size_order [Array]
+    # @param size_norm
+    # @param dashes [true, false, Array, Hash]
+    # @param markers [true, false, Array, Hash]
+    # @param style_order [Array]
+    # @param units [vector-like object, key in data]
+    # @param estimator [:mean]
+    # @param n_boot [Integer]
+    # @param random [Integer, Random, nil]
+    # @param sort [true, false]
+    # @param err_style [:band, :bars]
+    # @param err_params [Hash]
+    # @param error_bar
+    # @param x_scale [:linear, :log10]
+    # @param y_scale [:linear, :log10]
+    # @param legend [:auto, :brief, :full, false]
+    #        How to draw legend.  If :brief, numeric color and size variables
+    #        will be represented with a sample of evenly spaced values.  If
+    #        :full, every group will get an entry in the legend.  If :auto,
+    #        choose between brief or full representation based on number of
+    #        levels.  If false, no legend data is added and no legend is drawn.
+    def line_plot(x: nil, y: nil, color: nil, style: nil, size: nil,
+                  data: nil, key_color: nil, palette: nil, color_order: nil,
+                  color_norm: nil, sizes: nil, size_order: nil, size_norm: nil,
+                  markers: nil, dashes: true, style_order: nil,
+                  units: nil, estimator: :mean, n_boot: 1000, random: nil,
+                  sort: true, err_style: :band, err_params: nil, error_bar: [:ci, 95],
+                  x_scale: :linear, y_scale: :linear, legend: :auto, **options, &block)
+      Plotters::LinePlotter.new(
+        data: data,
+        variables: { x: x, y: y, color: color, style: style, size: size },
+        key_color: key_color,
+        palette: palette,
+        color_order: color_order,
+        color_norm: color_norm,
+        sizes: sizes,
+        size_order: size_order,
+        size_norm: size_norm,
+        markers: markers,
+        dashes: dashes,
+        style_order: style_order,
+        units: units,
+        estimator: estimator,
+        n_boot: n_boot,
+        random: random,
+        sort: sort,
+        err_style: err_style,
+        err_params: err_params,
+        error_bar: error_bar,
+        x_scale: x_scale,
+        y_scale: y_scale,
+        legend: legend,
+        **options,
+        &block
+      )
+    end
+
     # Scatter plot
     #
     # @param x [vector-like object, key in data]
@@ -146,7 +216,7 @@ module Charty
     # @param size_order [Array]
     # @param size_norm
     # @param markers [true, false, Array, Hash]
-    # @param marker_order [Array]
+    # @param style_order [Array]
     # @param alpha [scalar number]
     #        Propotional opacity of the points.
     # @param legend [:auto, :brief, :full, false]
@@ -158,7 +228,7 @@ module Charty
     def scatter_plot(x: nil, y: nil, color: nil, style: nil, size: nil,
                      data: nil, key_color: nil, palette: nil, color_order: nil,
                      color_norm: nil, sizes: nil, size_order: nil, size_norm: nil,
-                     markers: true, marker_order: nil, alpha: nil, legend: :auto,
+                     markers: true, style_order: nil, alpha: nil, legend: :auto,
                      **options, &block)
       Plotters::ScatterPlotter.new(
         data: data,
@@ -171,7 +241,7 @@ module Charty
         size_order: size_order,
         size_norm: size_norm,
         markers: markers,
-        marker_order: marker_order,
+        style_order: style_order,
         alpha: alpha,
         legend: legend,
         **options,

data/lib/charty/plotters.rb

@@ -9,3 +9,4 @@ 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

@@ -8,12 +8,28 @@ module Charty
         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
@@ -22,6 +38,8 @@ module Charty
         @data = case data
                 when nil, Charty::Table
                   data
+                when method(:array?)
+                  Charty::Vector.new(data)
                 else
                   Charty::Table.new(data)
                 end
@@ -40,11 +58,7 @@ module Charty
       end
 
       def color_order=(color_order)
-        #@color_order = XXX
-        unless color_order.nil?
-          raise NotImplementedError,
-                "Specifying color_order is not supported yet"
-        end
+        @color_order = color_order
       end
 
       # TODO: move to categorical_plotter
@@ -144,13 +158,59 @@ module Charty
       end
 
       private def remove_na!(ary)
-        ary.reject! do |x|
-          next true if x.nil?
-          x.respond_to?(:nan?) && x.nan?
-        end
+        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

data/lib/charty/plotters/line_plotter.rb

@@ -0,0 +1,300 @@
+module Charty
+  module Plotters
+    class EstimateAggregator
+      def initialize(estimator, error_bar, n_boot, random)
+        @estimator = estimator
+        @method, @level = error_bar
+        @n_boot = n_boot
+        @random = random
+      end
+
+      # Perform aggregation
+      #
+      # @param data [Hash<Any, Charty::Table>]
+      # @param var_name [Symbol, String]  A column name to be aggregated
+      def aggregate(data, var_name)
+        values = data[var_name]
+        estimation = case @estimator
+                     when :count
+                       values.length
+                     when :mean
+                       values.mean
+                     end
+
+        n = values.length
+        case
+        # No error bars
+        when @method.nil?
+          err_min = err_max = Float::NAN
+        when n <= 1
+          err_min = err_max = Float::NAN
+
+        # User-defined method
+        when @method.respond_to?(:call)
+          err_min, err_max = @method.call(values)
+
+        # Parametric
+        when @method == :sd
+          err_radius = values.stdev * @level
+          err_min = estimation - err_radius
+          err_max = estimation + err_radius
+        when @method == :se
+          err_radius = values.stdev / Math.sqrt(n)
+          err_min = estimation - err_radius
+          err_max = estimation + err_radius
+
+        # Nonparametric
+        when @method == :pi
+          err_min, err_max = percentile_interval(values, @level)
+        when @method == :ci
+          # TODO: Support units
+          err_min, err_max =
+            Statistics.bootstrap_ci(values, @level, units: nil, func: @estimator,
+                                    n_boot: @n_boot, random: @random)
+        end
+
+        {
+          var_name => estimation,
+          "#{var_name}_min" => err_min,
+          "#{var_name}_max" => err_max
+        }
+      end
+
+      def percentile_interval(values, width)
+        q = [50 - width / 2, 50 + width / 2]
+        Statistics.percentile(values, q)
+      end
+    end
+
+    class LinePlotter < RelationalPlotter
+      def initialize(data: nil, variables: {}, **options, &block)
+        x, y, color, style, size = variables.values_at(:x, :y, :color, :style, :size)
+        super(x, y, color, style, size, data: data, **options, &block)
+
+        @comp_data = nil
+      end
+
+      attr_reader :estimator
+
+      def estimator=(estimator)
+        @estimator = check_estimator(estimator)
+      end
+
+      private def check_estimator(value)
+        case value
+        when nil, false
+          nil
+        when :count, "count"
+          :count
+        when :mean, "mean"
+          :mean
+        when :median
+          raise NotImplementedError,
+                "median estimator has not been supported yet"
+        when Proc
+          raise NotImplementedError,
+                "a callable estimator has not been supported yet"
+        else
+          raise ArgumentError,
+                "invalid value for estimator (%p for :mean)" % value
+        end
+      end
+
+      attr_reader :n_boot
+
+      def n_boot=(n_boot)
+        @n_boot = check_n_boot(n_boot)
+      end
+
+      private def check_n_boot(value)
+        case value
+        when Integer
+          if value <= 0
+            raise ArgumentError,
+                  "n_boot must be larger than zero, but %p is given" % value
+          end
+          value
+        else
+          raise ArgumentError,
+                "invalid value for n_boot (%p for an integer > 0)" % value
+        end
+      end
+
+      include RandomSupport
+
+      attr_reader :sort, :err_style, :err_kws, :error_bar, :x_scale, :y_scale
+
+      def sort=(val)
+        @sort = check_boolean(val, :sort)
+      end
+
+      def err_style=(val)
+        @err_style = check_err_style(val)
+      end
+
+      private def check_err_style(val)
+        case val
+        when :bars, "bars", :band, "band"
+          val.to_sym
+        else
+          raise ArgumentError,
+                "Invalid value for err_style (%p for :band or :bars)" % val
+        end
+      end
+
+      # parameters to draw error bars/bands
+      def err_params=(val)
+        unless val.nil?
+          raise NotImplementedError,
+                "Specifying `err_params` is not supported"
+        end
+      end
+
+      # The method and level to calculate error bars/bands
+      def error_bar=(val)
+        @error_bar = check_error_bar(val)
+      end
+
+      DEFAULT_ERROR_BAR_LEVELS = {
+        ci: 95,
+        pi: 95,
+        se: 1,
+        sd: 1
+      }.freeze
+
+      VALID_ERROR_BAR_METHODS = DEFAULT_ERROR_BAR_LEVELS.keys
+      VALID_ERROR_BAR_METHODS.concat(VALID_ERROR_BAR_METHODS.map(&:to_s))
+      VALID_ERROR_BAR_METHODS.freeze
+
+      private def check_error_bar(val)
+        case val
+        when nil
+          return [nil, nil]
+        when ->(x) { x.respond_to?(:call) }
+          return [val, nil]
+        when *VALID_ERROR_BAR_METHODS
+          method = val.to_sym
+          level = nil
+        when Array
+          if val.length != 2
+            raise ArgumentError,
+                  "The `error_bar` array has the wrong number of items " +
+                  "(%d for 2)" % val.length
+          end
+          method, level = *val
+        else
+          raise ArgumentError,
+                "Unable to recognize the value for `error_bar`: %p" % val
+        end
+
+        case method
+        when *VALID_ERROR_BAR_METHODS
+          method = method.to_sym
+        else
+          error_message = "The value for method in `error_bar` array must be in %p, but %p was passed" % [
+            DEFAULT_ERROR_BAR_LEVELS.keys,
+            method
+          ]
+          raise ArgumentError, error_message
+        end
+
+        case level
+        when Numeric
+          # nothing to do
+        when nil
+          level = DEFAULT_ERROR_BAR_LEVELS[method]
+        else
+          raise ArgumentError,
+                "The value of level in `error_bar` array must be a number "
+        end
+
+        [method, level]
+      end
+
+      def x_scale=(val)
+        @x_scale = check_axis_scale(val, :x)
+      end
+
+      def y_scale=(val)
+        @y_scale = check_axis_scale(val, :y)
+      end
+
+      private def check_axis_scale(val, axis)
+        case val
+        when :linear, "linear", :log10, "log10"
+          val.to_sym
+        else
+          raise ArgumentError,
+                "The value of `#{axis}_scale` is worng: %p" % val,
+                caller
+        end
+      end
+
+      private def render_plot(backend, **)
+        draw_lines(backend)
+        annotate_axes(backend)
+      end
+
+      private def draw_lines(backend)
+        map_color(palette: palette, order: color_order, norm: color_norm)
+        map_size(sizes: sizes, order: size_order, norm: size_norm)
+        map_style(markers: markers, dashes: dashes, order: style_order)
+
+        aggregator = EstimateAggregator.new(estimator, error_bar, n_boot, random)
+
+        agg_var = :y
+        grouper = :x
+        grouping_vars = [:color, :size, :style]
+
+        each_subset(grouping_vars, processed: true) do |sub_vars, sub_data|
+          if self.sort
+            sort_cols = [:units, :x, :y] & self.variables.keys
+            sub_data = sub_data.sort_values(sort_cols)
+          end
+
+          unless estimator.nil?
+            if self.variables.include?(:units)
+              raise "`estimator` is must be nil when specifying `units`"
+            end
+
+            grouped = sub_data.group_by(grouper, sort: self.sort)
+            sub_data = grouped.apply(agg_var, &aggregator.method(:aggregate)).reset_index
+          end
+
+          # TODO: perform inverse conversion of axis scaling before plot
+
+          unit_grouping = if self.variables.include?(:units)
+                            sub_data.group_by(:units).each_group
+                          else
+                            { nil => sub_data }
+                          end
+          unit_grouping.each do |_unit_value, unit_data|
+            ci_params = unless self.estimator.nil? || self.error_bar.nil?
+                          {
+                            style: self.err_style,
+                            y_min: sub_data[:y_min],
+                            y_max: sub_data[:y_max]
+                          }
+                        end
+            backend.line(unit_data[:x], unit_data[:y], self.variables,
+                         color: sub_vars[:color], color_mapper: @color_mapper,
+                         size: sub_vars[:size], size_mapper: @size_mapper,
+                         style: sub_vars[:style], style_mapper: @style_mapper,
+                         ci_params: ci_params)
+          end
+        end
+
+        if legend
+          backend.add_line_plot_legend(@variables, @color_mapper, @size_mapper, @style_mapper, legend)
+        end
+      end
+
+      private def annotate_axes(backend)
+        xlabel = self.variables[:x]
+        ylabel = self.variables[:y]
+        backend.set_xlabel(xlabel) unless xlabel.nil?
+        backend.set_ylabel(ylabel) unless ylabel.nil?
+      end
+    end
+  end
+end