charty 0.2.4 → 0.2.9

data/lib/charty/plotters/scatter_plotter.rb

@@ -6,7 +6,7 @@ module Charty
         super(x, y, color, style, size, data: data, **options, &block)
       end
 
-      attr_reader :alpha, :legend
+      attr_reader :alpha
 
       def alpha=(val)
         case val
@@ -25,18 +25,6 @@ module Charty
         end
       end
 
-      def legend=(val)
-        case val
-        when :auto, :brief, :full, false
-          @legend = val
-        when "auto", "brief", "full"
-          @legend = val.to_sym
-        else
-          raise ArgumentError,
-                "invalid value of legend (%p for :auto, :brief, :full, or false)" % val
-        end
-      end
-
       attr_reader :line_width, :edge_color
 
       def line_width=(val)
@@ -47,26 +35,15 @@ module Charty
         @line_width = check_color(val, :edge_color, allow_nil: true)
       end
 
-      def render
-        backend = Backends.current
-        backend.begin_figure
-        draw_points(backend)
-        annotate_axes(backend)
-        backend.show
-      end
-
-      def save(filename, **opts)
-        backend = Backends.current
-        backend.begin_figure
+      private def render_plot(backend, **)
         draw_points(backend)
         annotate_axes(backend)
-        backend.save(filename, **opts)
       end
 
       private def draw_points(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, order: marker_order)
+        map_style(markers: markers, order: style_order)
 
         data = @plot_data.drop_na
 
@@ -84,9 +61,12 @@ module Charty
           x, y, @variables,
           color: color, color_mapper: @color_mapper,
           style: style, style_mapper: @style_mapper,
-          size: size, size_mapper: @size_mapper,
-          legend: legend
+          size: size, size_mapper: @size_mapper
         )
+
+        if legend
+          backend.add_scatter_plot_legend(@variables, @color_mapper, @size_mapper, @style_mapper, legend)
+        end
       end
 
       private def annotate_axes(backend)
@@ -94,21 +74,6 @@ module Charty
         ylabel = self.variables[:y]
         backend.set_xlabel(xlabel) unless xlabel.nil?
         backend.set_ylabel(ylabel) unless ylabel.nil?
-
-        if legend
-          add_legend_data(backend)
-        end
-      end
-
-      private def add_legend_data(backend)
-        # TODO: Legend Support
-        verbosity = legend
-        verbosity = :auto if verbosity == true
-
-        titles = [:color, :size, :style].filter_map do |v|
-          variables[v] if variables.key?(v)
-        end
-        legend_title = titles.length == 1 ? titles[0] : ""
       end
     end
   end

data/lib/charty/statistics.rb

@@ -10,6 +10,10 @@ module Charty
       def self.stdev(enum, population: false)
         enum.stdev(population: population)
       end
+
+      def self.histogram(ary, *args, **kwargs)
+        ary.histogram(*args, **kwargs)
+      end
     rescue LoadError
       def self.mean(enum)
         xs = enum.to_a
@@ -24,6 +28,11 @@ module Charty
         var = xs.map {|x| (x - mean)**2 }.sum / (n - ddof)
         Math.sqrt(var)
       end
+
+      def self.histogram(ary, *args, **kwargs)
+        raise NotImplementedError,
+              "histogram is currently supported only with enumerable-statistics"
+      end
     end
 
     def self.bootstrap(vector, n_boot: 2000, func: :mean, units: nil, random: nil)
@@ -83,9 +92,9 @@ module Charty
         "structured bootstrapping has not been supported yet"
     end
 
-    def self.bootstrap_ci(*vectors, which, n_boot: 2000, func: :mean, units: nil, random: nil)
+    def self.bootstrap_ci(*vectors, width, n_boot: 2000, func: :mean, units: nil, random: nil)
       boot = bootstrap(*vectors, n_boot: n_boot, func: func, units: units, random: random)
-      q = [50 - which / 2, 50 + which / 2]
+      q = [50 - width / 2, 50 + width / 2]
       if boot.respond_to?(:percentile)
         boot.percentile(q)
       else

data/lib/charty/table.rb

@@ -13,7 +13,6 @@ module Charty
 
   class Table
     extend Forwardable
-    include MissingValueSupport
 
     def initialize(data, **kwargs)
       adapter_class = TableAdapters.find_adapter_class(data)
@@ -34,6 +33,20 @@ module Charty
     def_delegators :adapter, :index, :index=
 
     def_delegator :@adapter, :column_names
+
+    def column?(name)
+      return true if column_names.include?(name)
+
+      case name
+      when String
+        column_names.include?(name.to_sym)
+      when Symbol
+        column_names.include?(name.to_s)
+      else
+        false
+      end
+    end
+
     def_delegator :@adapter, :data, :raw_data
 
     def ==(other)
@@ -65,6 +78,10 @@ module Charty
       end
     end
 
+    def group_by(grouper, sort: true, drop_na: true)
+      adapter.group_by(self, grouper, sort, drop_na)
+    end
+
     def to_a(x=nil, y=nil, z=nil)
       case
       when defined?(Daru::DataFrame) && table.kind_of?(Daru::DataFrame)
@@ -99,21 +116,114 @@ module Charty
     end
 
     def drop_na
-      # TODO: Must implement this method in each adapter
-      missing_index = index.select do |i|
-        column_names.any? do |key|
-          missing_value?(self[key][i])
+      @adapter.drop_na || self
+    end
+
+    def_delegator :adapter, :sort_values
+
+    def_delegator :adapter, :reset_index
+
+    class GroupByBase
+    end
+
+    class HashGroupBy < GroupByBase
+      def initialize(table, grouper, sort, drop_na)
+        @table = table
+        @grouper = check_grouper(grouper)
+        init_groups(sort, drop_na)
+      end
+
+      private def check_grouper(grouper)
+        case grouper
+        when Symbol, String, Array
+          # TODO check column existence
+          return grouper
+        when Charty::Vector
+          if @table.length != grouper.length
+            raise ArgumentError,
+                  "Wrong number of items in grouper array " +
+                  "(%p for %p)" % [val.length, @table.length]
+          end
+          return grouper
+        when ->(x) { x.respond_to?(:call) }
+          raise NotImplementedError,
+                "A callable grouper is unsupported"
+        else
+          raise ArgumentError,
+                "Unable to recognize the value for `grouper`: %p" % val
         end
       end
-      if missing_index.empty?
-        self
-      else
-        select_index = index.to_a - missing_index
-        new_data = column_names.map { |key|
-          vals = select_index.map {|i| self[key][i] }
-          [key, vals]
-        }.to_h
-        Charty::Table.new(new_data, index: select_index)
+
+      private def init_groups(sort, drop_na)
+        case @grouper
+        when Symbol, String
+          column = @table[@grouper]
+          @indices = (0 ... @table.length).group_by do |i|
+            column.data[i]
+          end
+        when Array
+          @indices = (0 ... @table.length).group_by { |i|
+            @grouper.map {|j| @table[j].data[i] }
+          }
+        when Charty::Vector
+          @indices = (0 ... @table.length).group_by do |i|
+            @grouper.data[i]
+          end
+        end
+
+        if drop_na
+          case @grouper
+          when Array
+            @indices.reject! {|key, | key.any? {|k| Util.missing?(k) } }
+          else
+            @indices.reject! {|key, | Util.missing?(key) }
+          end
+        end
+
+        if sort
+          @indices = @indices.sort_by {|key, | key }.to_h
+        end
+      end
+
+      def indices
+        @indices.dup
+      end
+
+      def group_keys
+        @indices.keys
+      end
+
+      def each_group_key(&block)
+        @indices.each_key(&block)
+      end
+
+      def apply(*args, &block)
+        Charty::Table.new(
+          each_group.map { |_key, table|
+            block.call(table, *args)
+          },
+          index: Charty::Index.new(@indices.keys, name: @grouper)
+        )
+      end
+
+      def each_group
+        return enum_for(__method__) unless block_given?
+
+        @indices.each_key do |key|
+          yield(key, self[key])
+        end
+      end
+
+      def [](key)
+        return nil unless @indices.key?(key)
+
+        index = @indices[key]
+        Charty::Table.new(
+          @table.column_names.map {|col|
+            [col, @table[col].values_at(*index)]
+          }.to_h,
+          index: index
+        )
       end
     end
   end

data/lib/charty/table_adapters/base_adapter.rb

@@ -33,6 +33,10 @@ module Charty
         end
       end
 
+      def group_by(table, grouper, sort, drop_na)
+        Table::HashGroupBy.new(table, grouper, sort, drop_na)
+      end
+
       def compare_data_equality(other)
         columns.each do |name|
           if self[nil, name] != other[nil, name]
@@ -42,6 +46,99 @@ module Charty
         true
       end
 
+      def drop_na
+        # TODO: Must implement this method in each adapter
+        missing_index = index.select do |i|
+          column_names.any? do |key|
+            Util.missing?(self[i, key])
+          end
+        end
+        if missing_index.empty?
+          nil
+        else
+          select_index = index.to_a - missing_index
+          new_data = column_names.map { |key|
+            vals = select_index.map {|i| self[i, key] }
+            [key, vals]
+          }.to_h
+          Charty::Table.new(new_data, index: select_index)
+        end
+      end
+
+      def sort_values(by, na_position: :last)
+        na_cmp_val = check_na_position(na_position)
+        case by
+        when String, Symbol
+          order = (0 ... length).sort do |i, j|
+            a = self[i, by]
+            b = self[j, by]
+            case
+            when Util.missing?(a)  # missing > b
+              na_cmp_val
+            when Util.missing?(b)  # a < missing
+              -na_cmp_val
+            else
+              cmp = a <=> b
+              if cmp == 0
+                i <=> j
+              else
+                cmp
+              end
+            end
+          end
+        when Array
+          order = (0 ... length).sort do |i, j|
+            cmp = 0
+            by.each do |key|
+              a = self[i, key]
+              b = self[j, key]
+              case
+              when Util.missing?(a)  # missing > b
+                cmp = na_cmp_val
+                break
+              when Util.missing?(b)  # a < missing
+                cmp = -na_cmp_val
+                break
+              else
+                cmp = a <=> b
+                break if cmp != 0
+              end
+            end
+            if cmp == 0
+              i <=> j
+            else
+              cmp
+            end
+          end
+        else
+          raise ArgumentError,
+                "%p is invalid value for `by`" % by
+        end
+
+        Charty::Table.new(
+          column_names.map { |name|
+            [
+              name,
+              self[nil, name].values_at(*order)
+            ]
+          }.to_h,
+          index: index.to_a.values_at(*order)
+        )
+      end
+
+      private def check_na_position(val)
+        case val
+        when :first, "first"
+          -1
+        when :last, "last"
+          1
+        else
+          raise ArgumentError,
+                "`na_position` must be :first or :last",
+                caller
+        end
+      end
+
       private def check_and_convert_index(values, name, expected_length)
         case values
         when Index, Range

data/lib/charty/table_adapters/daru_adapter.rb

@@ -21,6 +21,8 @@ module Charty
 
       attr_reader :data
 
+      def_delegator :data, :size, :length
+
       def index
         DaruIndex.new(data.index)
       end

data/lib/charty/table_adapters/datasets_adapter.rb

@@ -13,12 +13,19 @@ module Charty
       def initialize(dataset)
         @table = dataset.to_table
         @records = []
+
+        self.columns = self.column_names
+        self.index = 0 ... length
       end
 
       def data
         @table
       end
 
+      def column_length
+        column_names.length
+      end
+
       def column_names
         @table.column_names
       end

data/lib/charty/table_adapters/hash_adapter.rb

@@ -20,6 +20,8 @@ module Charty
           end
         when Hash
           true
+        when ->(x) { defined?(CSV::Table) && x.is_a?(CSV::Table) }
+          true
         end
       end
 
@@ -27,6 +29,7 @@ module Charty
         case data
         when Charty::Vector
           true
+        # TODO: Use vector adapter to detect them:
         when Array, method(:daru_vector?), method(:narray_vector?), method(:nmatrix_vector?),
              method(:numpy_vector?), method(:pandas_series?)
           true
@@ -65,14 +68,22 @@ module Charty
           when Numeric, String, Time, Date
             arrays = [data]
           when Hash
-            raise NotImplementedError,
-                  "an array of records is not supported"
+            columns ||= data.map(&:keys).inject(&:|)
+            arrays = columns.map { [] }
+            data.each do |record|
+              columns.each_with_index do |key, i|
+                arrays[i] << record[key]
+              end
+            end
           when self.class.method(:array?)
             unsupported_data_format unless data.all?(&self.class.method(:array?))
             arrays = data.map(&:to_a).transpose
           else
             unsupported_data_format
           end
+        when ->(x) { defined?(CSV::Table) && x.is_a?(CSV::Table) }
+          columns ||= data.headers
+          arrays = data.headers.map {|x| data[x] }
         else
           unsupported_data_format
         end
@@ -88,7 +99,7 @@ module Charty
 
       private def check_data(arrays, columns, index)
         # NOTE: After Ruby 2.7, we can write the following code by filter_map:
-        #         indexes = arrays.filter_map {|ary| ary.index if ary.is_a?(Charty::Vector) }
+        #         indexes = Util.filter_map(arrays) {|ary| ary.index if ary.is_a?(Charty::Vector) }
         indexes = []
         arrays.each do |array|
           index = case array
@@ -196,6 +207,11 @@ module Charty
         end
       end
 
+      def reset_index
+        index_name = index.name || :index
+        Charty::Table.new({ index_name => index.to_a }.merge(data))
+      end
+
       private def make_data_from_records(data, columns)
         n_rows = data.length
         n_columns = data.map(&:size).max