charty 0.2.3 → 0.2.8

data/lib/charty/backends/rubyplot.rb

@@ -33,7 +33,7 @@ module Charty
         @plot.show
       end
 
-      def render(context, filename="")
+      def old_style_render(context, filename="")
         FileUtils.mkdir_p(File.dirname(filename))
         plot(@plot, context).write(filename)
       end

data/lib/charty/cache_dir.rb

@@ -0,0 +1,27 @@
+require "pathname"
+
+module Charty
+  module CacheDir
+    module_function
+
+    def cache_dir_path
+      platform_cache_dir_path + "charty"
+    end
+
+    def platform_cache_dir_path
+      base_dir = case RUBY_PLATFORM
+                 when /mswin/, /mingw/
+                   ENV.fetch("LOCALAPPDATA", "~/AppData/Local")
+                 when /darwin/
+                   "~/Library/Caches"
+                 else
+                   ENV.fetch("XDG_CACHE_HOME", "~/.cache")
+                 end
+      Pathname(base_dir).expand_path
+    end
+
+    def path(*path_components)
+      cache_dir_path.join(*path_components)
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+require "forwardable"
+
+module Charty
+  class Index
+    extend Forwardable
+    include Enumerable
+
+    def initialize(values, name: nil)
+      @values = values
+      @name = name
+    end
+
+    attr_reader :values
+    attr_accessor :name
+
+    def_delegators :values, :length, :size, :each, :to_a
+
+    def ==(other)
+      case other
+      when DaruIndex, PandasIndex
+        return false if length != other.length
+        to_a == other.to_a
+      when Index
+        return false if length != other.length
+        return true if values == other.values
+        to_a == other.to_a
+      else
+        super
+      end
+    end
+
+    def [](i)
+      case i
+      when 0 ... length
+        values[i]
+      else
+        raise IndexError, "index out of range"
+      end
+    end
+
+    def loc(key)
+      values.index(key)
+    end
+
+    def union(other)
+      case other
+      when PandasIndex
+        index = PandasIndex.try_convert(self)
+        return index.union(other) if index
+      end
+
+      Index.new(to_a.union(other.to_a), name: name)
+    end
+  end
+
+  class RangeIndex < Index
+    def initialize(values, name: nil)
+      if values.is_a?(Range) && values.begin.is_a?(Integer) && values.end.is_a?(Integer)
+        super
+      else
+        raise ArgumentError, "values must be an integer range"
+      end
+    end
+
+    def length
+      size
+    end
+
+    def [](i)
+      case i
+      when 0 ... length
+        values.begin + i
+      else
+        raise IndexError, "index out of range (#{i} for 0 ... #{length})"
+      end
+    end
+
+    def loc(key)
+      case key
+      when Integer
+        if values.cover?(key)
+          return key - values.begin
+        end
+      end
+    end
+
+    def union(other)
+      case other
+      when RangeIndex
+        return union(other.values)
+      when Range
+        if disjoint_range?(values, other)
+          return Index.new(values.to_a.union(other.to_a))
+        end
+        new_beg = [values.begin, other.begin].min
+        new_end = [values.end,   other.end  ].max
+        new_range = if values.end < new_end
+                      if other.exclude_end?
+                        new_beg ... new_end
+                      else
+                        new_beg .. new_end
+                      end
+                    elsif other.end < new_end
+                      if values.exclude_end?
+                        new_beg ... new_end
+                      else
+                        new_beg .. new_end
+                      end
+                    else
+                      if values.exclude_end? && other.exclude_end?
+                        new_beg ... new_end
+                      else
+                        new_beg .. new_end
+                      end
+                    end
+        RangeIndex.new(new_range)
+      else
+        super
+      end
+    end
+
+    private def disjoint_range?(r1, r2)
+      r1.end < r2.begin || r2.end < r1.begin
+    end
+  end
+
+  class DaruIndex < Index
+    def_delegators :values, :name, :name=
+
+    def length
+      size
+    end
+
+    def ==(other)
+      case other
+      when DaruIndex
+        values == other.values
+      else
+        super
+      end
+    end
+  end
+
+  class PandasIndex < Index
+    def self.try_convert(obj)
+      case obj
+      when PandasIndex
+        obj
+      when ->(x) { defined?(Pandas) && x.is_a?(Pandas::Index) }
+        PandasIndex.new(obj)
+      when RangeIndex, Range
+        obj = obj.values if obj.is_a?(RangeIndex)
+        stop = if obj.exclude_end?
+                 obj.end
+               else
+                 obj.end + 1
+               end
+        PandasIndex.new(Pandas.RangeIndex.new(obj.begin, stop))
+      when ->(x) { defined?(Enumerator::ArithmeticSequence) && x.is_a?(Enumerator::ArithmeticSequence) }
+        stop = if obj.exclude_end?
+                 obj.end
+               else
+                 obj.end + 1
+               end
+        PandasIndex.new(Pandas::RangeIndex.new(obj.begin, stop, obj.step))
+      when Index, Array, DaruIndex, ->(x) { defined?(Daru) && x.is_a?(Daru::Index) }
+        obj = obj.values if obj.is_a?(Index)
+        PandasIndex.new(Pandas::Index.new(obj.to_a))
+      else
+        nil
+      end
+    end
+
+    def_delegators :values, :name, :name=
+
+    def length
+      size
+    end
+
+    def ==(other)
+      case other
+      when PandasIndex
+        Numpy.all(values == other.values)
+      when Index
+        return false if length != other.length
+        Numpy.all(values == other.values.to_a)
+      else
+        super
+      end
+    end
+
+    def each(&block)
+      return enum_for(__method__) unless block_given?
+
+      i, n = 0, length
+      while i < n
+        yield self[i]
+        i += 1
+      end
+    end
+
+    def union(other)
+      other = PandasIndex.try_convert(other)
+      # NOTE: Using `sort=False` in pandas.Index#union does not produce pandas.RangeIndex.
+      # TODO: Reconsider to use `sort=True` here.
+      PandasIndex.new(values.union(other.values, sort: false))
+    end
+
+    private def arithmetic_sequence?(x)
+      defined?(Enumerator::ArithmeticSequence) && x.is_a?(Enumerator::ArithmeticSequence)
+    end
+  end
+end

data/lib/charty/iruby_helper.rb

@@ -0,0 +1,18 @@
+module Charty
+  module IRubyHelper
+    module_function
+
+    def iruby_notebook?
+      # TODO: This cannot distinguish notebook and console.
+      defined?(IRuby)
+    end
+
+    def vscode?
+      ENV.key?("VSCODE_PID")
+    end
+
+    def nteract?
+      ENV.key?("NTERACT_EXE")
+    end
+  end
+end

data/lib/charty/linspace.rb

@@ -8,7 +8,7 @@ module Charty
     end
 
     def each(&block)
-      step = (@range.end - @range.begin).to_f / @num_step
+      step = (@range.end - @range.begin).to_r / (@num_step - 1)
       (@num_step - 1).times do |i|
         block.call(@range.begin + i * step)
       end

data/lib/charty/plot_methods.rb

@@ -2,16 +2,291 @@ module Charty
   module PlotMethods
     # Show the given data as rectangular bars.
     #
-    # @param x
-    # @param y
-    # @param color
-    # @param data
-    def bar_plot(x=nil, y=nil, color=nil, **options, &block)
-      Plotters::BarPlotter.new(x, y, color, **options, &block)
+    # @param x  x-dimension input for plotting long-form data.
+    # @param y  y-dimension input for plotting long-form data.
+    # @param color  color-dimension input for plotting long-form data.
+    # @param data  Dataset for plotting.
+    # @param order  Order of the categorical dimension to plot the categorical levels in.
+    # @param color_order  Order of the color dimension to plot the categorical levels in.
+    # @param estimator  Statistical function to estimate withint each categorical bin.
+    # @param ci  Size of confidence intervals to draw around estimated values.
+    # @param n_boot  The size of bootstrap sample to use when computing confidence intervals.
+    # @param units  Identifier of sampling unit.
+    # @param random  Random seed or random number generator for reproducible bootstrapping.
+    # @param orient  Orientation of the plot (:v for vertical, or :h for
+    #        horizontal).
+    # @param key_color  Color for all of the elements, or seed for a gradient palette.
+    # @param palette  Colors to use for the different levels of the color-dimension variable.
+    # @param saturation  Propotion of the original saturation to draw colors.
+    # @param error_color  Color for the lines that represent the confidence intervals.
+    # @param error_width  Thickness of error bar lines (and caps).
+    # @param cap_size  Width of the caps on error bars.
+    # @param dodge  [true,false]  If true, bar position is shifted along the
+    #        categorical axis for avoid overlapping when the color-dimension is used.
+    def bar_plot(x: nil, y: nil, color: nil, data: nil,
+                 order: nil, color_order: nil,
+                 estimator: :mean, ci: 95, n_boot: 1000, units: nil, random: nil,
+                 orient: nil, key_color: nil, palette: nil, saturation: 1r,
+                 error_color: [0.26, 0.26, 0.26], error_width: nil, cap_size: nil,
+                 dodge: true, **options, &block)
+      Plotters::BarPlotter.new(
+        data: data, variables: { x: x, y: y, color: color },
+        order: order, orient: orient,
+        estimator: estimator, ci: ci, n_boot: n_boot, units: units, random: random,
+        color_order: color_order, key_color: key_color, palette: palette, saturation: saturation,
+        error_color: error_color, error_width: error_width, cap_size: cap_size,
+        dodge: dodge,
+        **options, &block
+      )
     end
 
-    def box_plot(x=nil, y=nil, color=nil, **options, &block)
-      Plotters::BoxPlotter.new(x, y, color, **options, &block)
+    def count_plot(x: nil, y: nil, color: nil, data: nil,
+                   order: nil, color_order: nil,
+                   orient: nil, key_color: nil, palette: nil, saturation: 1r,
+                   dodge: true, **options, &block)
+      case
+      when x.nil? && !y.nil?
+        x = y
+        orient = :h
+      when y.nil? && !x.nil?
+        y = x
+        orient = :v
+      when !x.nil? && !y.nil?
+        raise ArgumentError,
+              "Unable to pass both x and y to count_plot"
+      end
+
+      Plotters::CountPlotter.new(
+        data: data,
+        variables: { x: x, y: y, color: color },
+        order: order,
+        orient: orient,
+        estimator: :count,
+        ci: nil,
+        units: nil,
+        random: nil,
+        color_order: color_order,
+        key_color: key_color,
+        palette: palette,
+        saturation: saturation,
+        dodge: dodge,
+        **options
+      ) do |plotter|
+        plotter.value_label = "count"
+        block.(plotter) unless block.nil?
+      end
+    end
+
+    # Show the distributions of the given data by boxes and whiskers.
+    #
+    # @param x  X-dimension input for plotting long-Form data.
+    # @param y  Y-dimension input for plotting long-form data.
+    # @param color  Color-dimension input for plotting long-form data.
+    # @param data  Dataset for plotting.
+    # @param order  Order of the categorical dimension to plot the categorical
+    #        levels in.
+    # @param color_order  Order of the color dimension to plot the categorical
+    #        levels in.
+    # @param orient  Orientation of the plot (:v for vertical, or :h for
+    #        horizontal).
+    # @param key_color  Color for all of the elements, or seed for a gradient
+    #        palette.
+    # @param palette  Colors to use for the different levels of the
+    #        color-dimension variable.
+    # @param saturation  Propotion of the original saturation to draw colors.
+    # @param width  Width of a full element when not using the color-dimension,
+    #        or width of all the elements for one level of the major grouping
+    #        variable.
+    # @param dodge  [true,false]  If true, bar position is shifted along the
+    #        categorical axis for avoid overlapping when the color-dimension
+    #        is used.
+    # @param flier_size  Size of the markers used to indicate outlier
+    #        observations.
+    # @param line_width  Width of the gray lines that frame the plot elements.
+    # @param whisker  Propotion of the IQR past the low and high quartiles to
+    #        extend the plot whiskers.  Points outside of this range will be
+    #        treated as outliers.
+    def box_plot(x: nil, y: nil, color: nil, data: nil,
+                 order: nil, color_order: nil,
+                 orient: nil, key_color: nil, palette: nil, saturation: 1r,
+                 width: 0.8r, dodge: true, flier_size: 5, line_width: nil,
+                 whisker: 1.5, **options, &block)
+      Plotters::BoxPlotter.new(
+        data: data,
+        variables: { x: x, y: y, color: color },
+        order: order,
+        color_order: color_order,
+        orient: orient,
+        key_color: key_color,
+        palette: palette,
+        saturation: saturation,
+        width: width,
+        dodge: dodge,
+        flier_size: flier_size,
+        line_width: line_width,
+        whisker: whisker,
+        **options,
+        &block
+      )
+    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]
+    # @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 markers [true, false, Array, Hash]
+    # @param style_order [Array]
+    # @param alpha [scalar number]
+    #        Propotional opacity of the points.
+    # @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 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, style_order: nil, alpha: nil, legend: :auto,
+                     **options, &block)
+      Plotters::ScatterPlotter.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,
+        style_order: style_order,
+        alpha: alpha,
+        legend: legend,
+        **options,
+        &block
+      )
+    end
+
+    def hist_plot(data: nil, x: nil, y: nil, color: nil,
+                  stat: :count, bins: :auto,
+                  key_color: nil, palette: nil, color_order: nil, color_norm: nil,
+                  legend: true, **options, &block)
+      # TODO: support following arguments
+      # - wiehgts
+      # - binwidth
+      # - binrange
+      # - discrete
+      # - cumulative
+      # - common_bins
+      # - common_norm
+      # - multiple
+      # - element
+      # - fill
+      # - shrink
+      # - kde
+      # - kde_params
+      # - line_params
+      # - thresh
+      # - pthresh
+      # - pmax
+      # - cbar
+      # - cbar_params
+      # - x_log_scale
+      # - y_log_scale
+      Plotters::HistogramPlotter.new(
+        data: data,
+        variables: { x: x, y: y, color: color },
+        stat: stat,
+        bins: bins,
+        key_color: key_color,
+        palette: palette,
+        color_order: color_order,
+        color_norm: color_norm,
+        legend: legend,
+        **options,
+        &block)
     end
   end