charty 0.2.0 → 0.2.6

data/lib/charty/plotters/scatter_plotter.rb

@@ -0,0 +1,80 @@
+module Charty
+  module Plotters
+    class ScatterPlotter < 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)
+      end
+
+      attr_reader :alpha
+
+      def alpha=(val)
+        case val
+        when nil, :auto, 0..1
+          @alpha = val
+        when "auto"
+          @alpha = val.to_sym
+        when Numeric
+          raise ArgumentError,
+                "the given alpha is out of bounds " +
+                "(%p for nil, :auto, or number 0..1)" % val
+        else
+          raise ArgumentError,
+                "invalid value of alpha " +
+                "(%p for nil, :auto, or number in 0..1)" % val
+        end
+      end
+
+      attr_reader :line_width, :edge_color
+
+      def line_width=(val)
+        @line_width = check_number(val, :line_width, allow_nil: true)
+      end
+
+      def edge_color=(val)
+        @line_width = check_color(val, :edge_color, allow_nil: true)
+      end
+
+      private def render_plot(backend, **)
+        draw_points(backend)
+        annotate_axes(backend)
+      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: style_order)
+
+        data = @plot_data.drop_na
+
+        # TODO: shold pass key_color to backend's scatter method.
+        #       In pyplot backend, it is passed as color parameter.
+
+        x = data[:x]
+        y = data[:y]
+        color = data[:color] if @variables.key?(:color)
+        style = data[:style] if @variables.key?(:style)
+        size = data[:size] if @variables.key?(:size)
+
+        # TODO: key_color
+        backend.scatter(
+          x, y, @variables,
+          color: color, color_mapper: @color_mapper,
+          style: style, style_mapper: @style_mapper,
+          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)
+        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

data/lib/charty/plotters/vector_plotter.rb

@@ -0,0 +1,6 @@
+module Charty
+  module Plotters
+    class VectorPlotter < AbstractPlotter
+    end
+  end
+end

data/lib/charty/statistics.rb

@@ -0,0 +1,114 @@
+module Charty
+  module Statistics
+    begin
+      require "enumerable/statistics"
+
+      def self.mean(enum)
+        enum.mean
+      end
+
+      def self.stdev(enum, population: false)
+        enum.stdev(population: population)
+      end
+    rescue LoadError
+      def self.mean(enum)
+        xs = enum.to_a
+        xs.sum / xs.length.to_f
+      end
+
+      def self.stdev(enum, population: false)
+        xs = enum.to_a
+        n = xs.length
+        mean = xs.sum.to_f / n
+        ddof = population ? 0 : 1
+        var = xs.map {|x| (x - mean)**2 }.sum / (n - ddof)
+        Math.sqrt(var)
+      end
+    end
+
+    def self.bootstrap(vector, n_boot: 2000, func: :mean, units: nil, random: nil)
+      n = vector.size
+      random = Charty::Plotters::RandomSupport.check_random(random)
+      func = Charty::Plotters::EstimationSupport.check_estimator(func)
+
+      if units
+        return structured_bootstrap(vector, n_boot, units, func, random)
+      end
+
+      if defined?(Pandas::Series) || defined?(Numpy::NDArray)
+        boot_dist = bootstrap_optimized_for_pycall(vector, n_boot, random, func)
+        return boot_dist if boot_dist
+      end
+
+      boot_dist = Array.new(n_boot) do |i|
+        resampler = Array.new(n) { random.rand(n) }
+
+        w ||= vector.values_at(*resampler)
+
+        case func
+        when :mean
+          mean(w)
+        end
+      end
+
+      boot_dist
+    end
+
+    private_class_method def self.bootstrap_optimized_for_pycall(vector, n_boot, random, func)
+      case
+      when vector.is_a?(Charty::Vector)
+        bootstrap_optimized_for_pycall(vector.data, n_boot, random, func)
+
+      when defined?(Pandas::Series) && vector.is_a?(Pandas::Series) || vector.is_a?(Numpy::NDArray)
+        # numpy is also available when pandas is available
+        n = vector.size
+        resampler = Numpy.empty(n, dtype: Numpy.intp)
+        Array.new(n_boot) do |i|
+          # TODO: Use Numo and MemoryView to reduce execution time
+          # resampler = Numo::Int64.new(n).rand(n)
+          # w = Numpy.take(vector, resampler)
+          n.times {|i| resampler[i] = random.rand(n) }
+          w = vector.take(resampler)
+
+          case func
+          when :mean
+            w.mean
+          end
+        end
+      end
+    end
+
+    private_class_method def self.structured_bootstrap(vector, n_boot, units, func, random)
+      raise NotImplementedError,
+        "structured bootstrapping has not been supported yet"
+    end
+
+    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 - width / 2, 50 + width / 2]
+      if boot.respond_to?(:percentile)
+        boot.percentile(q)
+      else
+        percentile(boot, q)
+      end
+    end
+
+    # TODO: optimize with introselect algorithm
+    def self.percentile(a, q)
+      return mean(a) if a.size == 0
+
+      a = a.sort
+      n = a.size
+      q.map do |x|
+        x = n * (x / 100.0)
+        i = x.floor
+        if i == n-1
+          a[i]
+        else
+          t = x - i
+          (1-t)*a[i] + t*a[i+1]
+        end
+      end
+    end
+  end
+end

data/lib/charty/table.rb

@@ -21,33 +21,67 @@ module Charty
       else
         @adapter = adapter_class.new(data, **kwargs)
       end
+
+      @column_cache = {}
     end
 
     attr_reader :adapter
 
+    def_delegators :adapter, :length, :column_length
+
+    def_delegators :adapter, :columns, :columns=
+    def_delegators :adapter, :index, :index=
+
     def_delegator :@adapter, :column_names
 
-    def columns
-      @column_accessor ||= ColumnAccessor.new(@adapter)
+    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)
+      return true if equal?(other)
+
+      case other
+      when Charty::Table
+        adapter == other.adapter
+      else
+        super
+      end
+    end
+
+    def empty?
+      length == 0
     end
 
-    def [](*args)
-      n_args = args.length
-      case n_args
-      when 1
-        row = nil
-        column = args[0]
-        @adapter[row, column]
-      when 2
-        row = args[0]
-        column = args[1]
-        @adapter[row, column]
+    def [](key)
+      key = case key
+            when Symbol
+              key
+            else
+              String.try_convert(key).to_sym
+            end
+      if @column_cache.key?(key)
+        @column_cache[key]
       else
-        message = "wrong number of arguments (given #{n_args}, expected 1..2)"
-        raise ArgumentError, message
+        @column_cache[key] = @adapter[nil, key]
       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)
@@ -80,5 +114,117 @@ module Charty
         i += 1
       end
     end
+
+    def drop_na
+      @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
+
+      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
 end

data/lib/charty/table_adapters.rb

@@ -15,9 +15,11 @@ module Charty
   end
 end
 
+require_relative 'table_adapters/base_adapter'
 require_relative 'table_adapters/hash_adapter'
 require_relative 'table_adapters/narray_adapter'
 require_relative 'table_adapters/datasets_adapter'
 require_relative 'table_adapters/daru_adapter'
 require_relative 'table_adapters/active_record_adapter'
 require_relative 'table_adapters/nmatrix_adapter'
+require_relative 'table_adapters/pandas_adapter'

data/lib/charty/table_adapters/active_record_adapter.rb

@@ -1,10 +1,8 @@
 module Charty
   module TableAdapters
-    class ActiveRecordAdapter
+    class ActiveRecordAdapter < BaseAdapter
       TableAdapters.register(:active_record, self)
 
-      include Enumerable
-
       def self.supported?(data)
         defined?(ActiveRecord::Relation) && data.is_a?(ActiveRecord::Relation)
       end
@@ -12,17 +10,27 @@ module Charty
       def initialize(data)
         @data = check_type(ActiveRecord::Relation, data, :data)
         @column_names = @data.column_names.freeze
-        @columns = nil
+        self.columns = Index.new(@column_names)
+        self.index = RangeIndex.new(0 ... length)
       end
 
-      attr_reader :column_names
+      attr_reader :data, :column_names
+
+      def_delegators :data, :size
+
+      alias length size
+
+      def column_length
+        column_names.length
+      end
 
       def [](row, column)
-        fetch_records unless @columns
+        fetch_records unless @columns_cache
         if row
-          @columns[resolve_column_index(column)][row]
+          @columns_cache[resolve_column_index(column)][row]
         else
-          @columns[resolve_column_index(column)]
+          column_data = @columns_cache[resolve_column_index(column)]
+          Vector.new(column_data, index: index, name: column)
         end
       end
 
@@ -43,7 +51,7 @@ module Charty
       end
 
       private def fetch_records
-        @columns = @data.pluck(*column_names).transpose
+        @columns_cache = @data.pluck(*column_names).transpose
       end
 
       private def check_type(type, data, name)