charty 0.1.5.dev → 0.2.5

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/missing_value_support.rb

@@ -0,0 +1,14 @@
+module Charty
+  module MissingValueSupport
+    def missing_value?(val)
+      case
+      when val.nil?
+        true
+      when val.respond_to?(:nan?) && val.nan?
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/charty/plot_methods.rb

@@ -0,0 +1,184 @@
+module Charty
+  module PlotMethods
+    # Show the given data as rectangular bars.
+    #
+    # @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 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
+
+    # 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 marker_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, marker_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,
+        marker_order: marker_order,
+        alpha: alpha,
+        legend: legend,
+        **options,
+        &block
+      )
+    end
+  end
+
+  extend PlotMethods
+end

data/lib/charty/plotter.rb

@@ -1,7 +1,8 @@
 module Charty
   class Plotter
-    def initialize(adapter_name)
-      @plotter_adapter =  PlotterAdapter.create(adapter_name)
+    def initialize(backend_name)
+      backend_class = Backends.find_backend_class(backend_name)
+      @backend = backend_class.new
     end
 
     def table=(data, **kwargs)
@@ -11,10 +12,11 @@ module Charty
     attr_reader :table
 
     def to_bar(x, y, **args, &block)
-      seriesx, seriesy = *table.to_a(x, y)
+      seriesx = table[x]
+      seriesy = table[y]
       xrange = (seriesx.min)..(seriesx.max)
       yrange = (seriesy.min)..(seriesy.max)
-      bar = bar do
+      bar do
         series seriesx, seriesy
         range x: xrange, y: yrange
         xlabel x
@@ -23,10 +25,11 @@ module Charty
     end
 
     def to_barh(x, y, **args, &block)
-      seriesx, seriesy = *table.to_a(x, y)
+      seriesx = table[x]
+      seriesy = table[y]
       xrange = (seriesx.min)..(seriesx.max)
       yrange = (seriesy.min)..(seriesy.max)
-      bar = barh do
+      barh do
         series seriesx, seriesy
         range x: xrange, y: yrange
         xlabel x
@@ -35,10 +38,10 @@ module Charty
     end
 
     def to_box_plot(x, y, **args, &block)
-      serieses = table.to_a(x, y)
+      serieses = [table[x], table[y]]
       xrange = 0..serieses.size
       yrange = (serieses.flatten.min - 1)..(serieses.flatten.max + 1)
-      box_plot = box_plot do
+      box_plot do
         data serieses
         range x: xrange, y: yrange
         xlabel x
@@ -47,10 +50,12 @@ module Charty
     end
 
     def to_bubble(x, y, z, **args, &block)
-      seriesx, seriesy, seriesz = *table.to_a(x, y, z)
+      seriesx = table[x]
+      seriesy = table[y]
+      seriesz = table[z]
       xrange = (seriesx.min)..(seriesx.max)
       yrange = (seriesy.min)..(seriesy.max)
-      bubble = bubble do
+      bubble do
         series seriesx, seriesy, seriesz
         range x: xrange, y: yrange
         xlabel x
@@ -59,10 +64,11 @@ module Charty
     end
 
     def to_curve(x, y, **args, &block)
-      seriesx, seriesy = *table.to_a(x, y)
+      seriesx = table[x]
+      seriesy = table[y]
       xrange = (seriesx.min)..(seriesx.max)
       yrange = (seriesy.min)..(seriesy.max)
-      curve = curve do
+      curve do
         series seriesx, seriesy
         range x: xrange, y: yrange
         xlabel x
@@ -71,10 +77,11 @@ module Charty
     end
 
     def to_scatter(x, y, **args, &block)
-      seriesx, seriesy = *table.to_a(x, y)
+      seriesx = table[x]
+      seriesy = table[y]
       xrange = (seriesx.min)..(seriesx.max)
       yrange = (seriesy.min)..(seriesy.max)
-      scatter = scatter do
+      scatter do
         series seriesx, seriesy
         range x: xrange, y: yrange
         xlabel x
@@ -84,10 +91,11 @@ module Charty
 
     def to_error_bar(x, y, **args, &block)
       # TODO: It is not yet decided how to include data including xerror and yerror.
-      seriesx, seriesy = *table.to_a(x, y)
+      seriesx = table[x]
+      seriesy = table[y]
       xrange = (seriesx.min)..(seriesx.max)
       yrange = (seriesy.min)..(seriesy.max)
-      error_bar = error_bar do
+      error_bar do
         series seriesx, seriesy
         range x: xrange, y: yrange
         xlabel x
@@ -96,10 +104,10 @@ module Charty
     end
 
     def to_hst(x, y, **args, &block)
-      serieses = table.to_a(x, y)
+      serieses = [table[x], table[y]]
       xrange = (serieses.flatten.min - 1)..(serieses.flatten.max + 1)
       yrange = 0..serieses[0].size
-      hist = hist do
+      hist do
         data serieses
         range x: xrange, y: yrange
         xlabel x
@@ -109,46 +117,46 @@ module Charty
 
     def bar(**args, &block)
       context = RenderContext.new :bar, **args, &block
-      context.apply(@plotter_adapter)
+      context.apply(@backend)
     end
 
     def barh(**args, &block)
       context = RenderContext.new :barh, **args, &block
-      context.apply(@plotter_adapter)
+      context.apply(@backend)
     end
 
     def box_plot(**args, &block)
       context = RenderContext.new :box_plot, **args, &block
-      context.apply(@plotter_adapter)
+      context.apply(@backend)
     end
 
     def bubble(**args, &block)
       context = RenderContext.new :bubble, **args, &block
-      context.apply(@plotter_adapter)
+      context.apply(@backend)
     end
 
     def curve(**args, &block)
       context = RenderContext.new :curve, **args, &block
-      context.apply(@plotter_adapter)
+      context.apply(@backend)
     end
 
     def scatter(**args, &block)
       context = RenderContext.new :scatter, **args, &block
-      context.apply(@plotter_adapter)
+      context.apply(@backend)
     end
 
     def error_bar(**args, &block)
       context = RenderContext.new :error_bar, **args, &block
-      context.apply(@plotter_adapter)
+      context.apply(@backend)
     end
 
     def hist(**args, &block)
       context = RenderContext.new :hist, **args, &block
-      context.apply(@plotter_adapter)
+      context.apply(@backend)
     end
 
     def layout(definition=:horizontal)
-      Layout.new(@plotter_adapter, definition)
+      Layout.new(@backend, definition)
     end
   end
 
@@ -160,7 +168,7 @@ module Charty
     def initialize(method, **args, &block)
       @method = method
       configurator = Configurator.new(**args)
-      configurator.instance_eval &block
+      configurator.instance_eval(&block)
       # TODO: label も外から付けられた方がよさそう
       (@range, @series, @function, @data, @title, @xlabel, @ylabel, @labels) = configurator.to_a
     end
@@ -229,25 +237,25 @@ module Charty
     end
 
     def render(filename=nil)
-      @plotter_adapter.render(self, filename)
+      @backend.old_style_render(self, filename)
     end
 
-    def save(filename=nil)
-      @plotter_adapter.save(self, filename)
+    def save(filename=nil, **kw)
+      @backend.old_style_save(self, filename, **kw)
     end
 
-    def apply(plotter_adapter)
+    def apply(backend)
       case
-        when !@series.empty?
-          plotter_adapter.series = @series
-        when @function
-          linspace = Linspace.new(@range[:x], 100)
-          # TODO: set label with function
-          # TODO: set ys to xs when gruff curve with function
-          @series << Series.new(linspace.to_a, linspace.map{|x| @function.call(x) }, label: "function" )
+      when !@series.empty?
+        backend.series = @series
+      when @function
+        linspace = Linspace.new(@range[:x], 100)
+        # TODO: set label with function
+        # TODO: set ys to xs when gruff curve with function
+        @series << Series.new(linspace.to_a, linspace.map{|x| @function.call(x) }, label: "function" )
       end
 
-      @plotter_adapter = plotter_adapter
+      @backend = backend
       self
     end
   end

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,183 @@
+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 inspect
+        "#<#{self.class}:0x%016x>" % self.object_id
+      end
+
+      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 save(filename, **kwargs)
+        backend = Backends.current
+        backend.begin_figure
+        render_plot(backend, **kwargs)
+        backend.save(filename, **kwargs)
+      end
+
+      def render(notebook: false, **kwargs)
+        backend = Backends.current
+        backend.begin_figure
+        render_plot(backend, notebook: notebook, **kwargs)
+        backend.render(notebook: notebook, **kwargs)
+      end
+
+      private def render_plot(*, **)
+        raise NotImplementedError,
+              "subclass must implement #{__method__}"
+      end
+
+      def to_iruby
+        render(notebook: iruby_notebook?)
+      end
+
+      private def iruby_notebook?
+        return false unless defined?(IRuby)
+        true # TODO: Check the server is notebook or not
+      end
+    end
+  end
+end