charty 0.2.3 → 0.2.4

data/lib/charty/plotters/scatter_plotter.rb

@@ -0,0 +1,115 @@
+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, :legend
+
+      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
+
+      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)
+        @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
+
+      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
+        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)
+
+        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,
+          legend: legend
+        )
+      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?
+
+        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
+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

@@ -7,8 +7,8 @@ module Charty
         enum.mean
       end
 
-      def self.stdev(enum)
-        enum.stdev
+      def self.stdev(enum, population: false)
+        enum.stdev(population: population)
       end
     rescue LoadError
       def self.mean(enum)
@@ -25,5 +25,90 @@ module Charty
         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, which, 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]
+      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

@@ -13,6 +13,7 @@ module Charty
 
   class Table
     extend Forwardable
+    include MissingValueSupport
 
     def initialize(data, **kwargs)
       adapter_class = TableAdapters.find_adapter_class(data)
@@ -21,31 +22,46 @@ 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_delegator :@adapter, :data, :raw_data
 
-    def columns
-      @column_accessor ||= ColumnAccessor.new(@adapter)
+    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
 
@@ -81,5 +97,24 @@ module Charty
         i += 1
       end
     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])
+        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)
+      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, :data
+      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)

data/lib/charty/table_adapters/base_adapter.rb

@@ -0,0 +1,69 @@
+require "forwardable"
+
+module Charty
+  module TableAdapters
+    class BaseAdapter
+      extend Forwardable
+      include Enumerable
+
+      attr_reader :columns
+
+      def columns=(values)
+        @columns = check_and_convert_index(values, :columns, column_length)
+      end
+
+      def column_names
+        columns.to_a
+      end
+
+      attr_reader :index
+
+      def index=(values)
+        @index = check_and_convert_index(values, :index, length)
+      end
+
+      def ==(other)
+        case other
+        when BaseAdapter
+          return false if columns != other.columns
+          return false if index != other.index
+          compare_data_equality(other)
+        else
+          false
+        end
+      end
+
+      def compare_data_equality(other)
+        columns.each do |name|
+          if self[nil, name] != other[nil, name]
+            return false
+          end
+        end
+        true
+      end
+
+      private def check_and_convert_index(values, name, expected_length)
+        case values
+        when Index, Range
+        else
+          unless (ary = Array.try_convert(values))
+            raise ArgumentError, "invalid object for %s: %p" % [name, values]
+          end
+          values = ary
+        end
+        if expected_length != values.size
+          raise ArgumentError,
+                "invalid length for %s (%d for %d)" % [name, values.size, expected_length]
+        end
+        case values
+        when Index
+          values
+        when Range
+          RangeIndex.new(values)
+        when Array
+          Index.new(values)
+        end
+      end
+    end
+  end
+end