charty 0.1.5.dev → 0.2.5

data/lib/charty/backends/rubyplot.rb

@@ -1,94 +1,102 @@
-require 'rubyplot'
+require 'fileutils'
 
 module Charty
-  class Rubyplot < PlotterAdapter
-    Name = "rubyplot"
+  module Backends
+    class Rubyplot
+      Backends.register(:rubyplot, self)
 
-    def initialize
-      @plot = ::Rubyplot
-    end
+      class << self
+        def prepare
+          require 'rubyplot'
+        end
+      end
 
-    def label(x, y)
-    end
+      def initialize
+        @plot = ::Rubyplot
+      end
 
-    def series=(series)
-      @series = series
-    end
+      def label(x, y)
+      end
+
+      def series=(series)
+        @series = series
+      end
 
-    def render_layout(layout)
-      (fig, axes) = *@plot.subplots(nrows: layout.num_rows, ncols: layout.num_cols)
-      layout.rows.each_with_index do |row, y|
-        row.each_with_index do |cel, x|
-          plot = layout.num_rows > 1 ? axes[y][x] : axes[x]
-          plot(plot, cel)
+      def render_layout(layout)
+        (_fig, axes) = *@plot.subplots(nrows: layout.num_rows, ncols: layout.num_cols)
+        layout.rows.each_with_index do |row, y|
+          row.each_with_index do |cel, x|
+            plot = layout.num_rows > 1 ? axes[y][x] : axes[x]
+            plot(plot, cel)
+          end
         end
+        @plot.show
       end
-      @plot.show
-    end
 
-    def render(context, filename="")
-      FileUtils.mkdir_p(File.dirname(filename))
-      plot(@plot, context).write(filename)
-    end
+      def old_style_render(context, filename="")
+        FileUtils.mkdir_p(File.dirname(filename))
+        plot(@plot, context).write(filename)
+      end
 
-    def plot(plot, context)
-      # case
-      # when plot.respond_to?(:xlim)
-      #   plot.xlim(context.range_x.begin, context.range_x.end)
-      #   plot.ylim(context.range_y.begin, context.range_y.end)
-      # when plot.respond_to?(:set_xlim)
-      #   plot.set_xlim(context.range_x.begin, context.range_x.end)
-      #   plot.set_ylim(context.range_y.begin, context.range_y.end)
-      # end
+      def plot(plot, context)
+        # case
+        # when plot.respond_to?(:xlim)
+        #   plot.xlim(context.range_x.begin, context.range_x.end)
+        #   plot.ylim(context.range_y.begin, context.range_y.end)
+        # when plot.respond_to?(:set_xlim)
+        #   plot.set_xlim(context.range_x.begin, context.range_x.end)
+        #   plot.set_ylim(context.range_y.begin, context.range_y.end)
+        # end
 
-      figure = ::Rubyplot::Figure.new
-      axes = figure.add_subplot 0,0
-      axes.title = context.title if context.title
-      axes.x_title = context.xlabel if context.xlabel
-      axes.y_title = context.ylabel if context.ylabel
+        figure = ::Rubyplot::Figure.new
+        axes = figure.add_subplot 0,0
+        axes.title = context.title if context.title
+        axes.x_title = context.xlabel if context.xlabel
+        axes.y_title = context.ylabel if context.ylabel
 
-      case context.method
-      when :bar
-        context.series.each do |data|
-          axes.bar! do |p|
-            p.data(data.xs.to_a)
-            p.label = data.label
+        case context.method
+        when :bar
+          context.series.each do |data|
+            axes.bar! do |p|
+              p.data(data.xs.to_a)
+              p.label = data.label
+            end
           end
-        end
-        figure
-      when :barh
-        raise NotImplementedError
-      when :box_plot
-        raise NotImplementedError
-      when :bubble
-        context.series.each do |data|
-          axes.bubble! do |p|
-            p.data(data.xs.to_a, data.ys.to_a, data.zs.to_a)
-            p.label = data.label if data.label
+          figure
+        when :barh
+          raise NotImplementedError
+        when :box_plot
+          raise NotImplementedError
+        when :bubble
+          context.series.each do |data|
+            axes.bubble! do |p|
+              p.data(data.xs.to_a, data.ys.to_a, data.zs.to_a)
+              p.label = data.label if data.label
+            end
           end
-        end
-        figure
-      when :curve
-        context.series.each do |data|
-          axes.line! do |p|
-            p.data(data.xs.to_a, data.ys.to_a)
-            p.label = data.label if data.label
+          figure
+        when :curve
+          context.series.each do |data|
+            axes.line! do |p|
+              p.data(data.xs.to_a, data.ys.to_a)
+              p.label = data.label if data.label
+            end
           end
-        end
-        figure
-      when :scatter
-        context.series.each do |data|
-          axes.scatter! do |p|
-            p.data(data.xs.to_a, data.ys.to_a)
-            p.label = data.label if data.label
+          figure
+        when :scatter
+          context.series.each do |data|
+            axes.scatter! do |p|
+              p.data(data.xs.to_a, data.ys.to_a)
+              p.label = data.label if data.label
+            end
           end
+          figure
+        when :error_bar
+          # refs. https://github.com/SciRuby/rubyplot/issues/26
+          raise NotImplementedError
+        when :hist
+          raise NotImplementedError
         end
-        figure
-      when :error_bar
-        # refs. https://github.com/SciRuby/rubyplot/issues/26
-        raise NotImplementedError
-      when :hist
-        raise NotImplementedError
       end
     end
   end

data/lib/charty/backends/unicode_plot.rb

@@ -0,0 +1,79 @@
+require 'stringio'
+
+module Charty
+  module Backends
+    class UnicodePlot
+      Backends.register(:unicode_plot, self)
+
+      class << self
+        def prepare
+          require 'unicode_plot'
+        end
+      end
+
+      def begin_figure
+        @figure = nil
+        @layout = {}
+      end
+
+      def bar(bar_pos, values, color: nil)
+        @figure = {
+          type: :bar,
+          bar_pos: bar_pos,
+          values: values
+        }
+      end
+
+      def box_plot(plot_data, positions, color:, gray:)
+        @figure = { type: :box, data: plot_data }
+      end
+
+      def set_xlabel(label)
+        @layout[:xlabel] = label
+      end
+
+      def set_ylabel(label)
+        @layout[:ylabel] = label
+      end
+
+      def set_xticks(values)
+        @layout[:xticks] = values
+      end
+
+      def set_xtick_labels(values)
+        @layout[:xtick_labels] = values
+      end
+
+      def set_xlim(min, max)
+        @layout[:xlim] = [min, max]
+      end
+
+      def disable_xaxis_grid
+        # do nothing
+      end
+
+      def show
+        case @figure[:type]
+        when :bar
+          plot = ::UnicodePlot.barplot(@layout[:xtick_labels], @figure[:values], xlabel: @layout[:xlabel])
+        when :box
+          plot = ::UnicodePlot.boxplot(@layout[:xtick_labels], @figure[:data], xlabel: @layout[:xlabel])
+        end
+        sio = StringIO.new
+        class << sio
+          def tty?; true; end
+        end
+        plot.render(sio)
+        sio.string
+      end
+
+      private
+
+      def show_bar(sio, figure, i)
+      end
+
+      def show_box(sio, figure, i)
+      end
+    end
+  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))
+    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