charty 0.1.5.dev → 0.2.5

data/lib/charty/plotters/scatter_plotter.rb

@@ -0,0 +1,104 @@
+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
+
+      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: 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 = Util.filter_map([:color, :size, :style]) 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

@@ -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, 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

@@ -1,11 +1,69 @@
+require 'forwardable'
 
 module Charty
+  class ColumnAccessor
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def [](column_name)
+      @adapter[nil, column_name]
+    end
+  end
+
   class Table
-    def initialize(table)
-      @table = table
+    extend Forwardable
+    include MissingValueSupport
+
+    def initialize(data, **kwargs)
+      adapter_class = TableAdapters.find_adapter_class(data)
+      if kwargs.empty?
+        @adapter = adapter_class.new(data)
+      else
+        @adapter = adapter_class.new(data, **kwargs)
+      end
+
+      @column_cache = {}
     end
 
-    attr_reader :table
+    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 ==(other)
+      return true if equal?(other)
+
+      case other
+      when Charty::Table
+        adapter == other.adapter
+      else
+        super
+      end
+    end
+
+    def empty?
+      length == 0
+    end
+
+    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
+        @column_cache[key] = @adapter[nil, key]
+      end
+    end
 
     def to_a(x=nil, y=nil, z=nil)
       case
@@ -39,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

@@ -0,0 +1,25 @@
+module Charty
+  module TableAdapters
+    @adapters = {}
+
+    def self.register(name, adapter_class)
+      @adapters[name] = adapter_class
+    end
+
+    def self.find_adapter_class(data)
+      @adapters.each_value do |adapter_class|
+        return adapter_class if adapter_class.supported?(data)
+      end
+      raise ArgumentError, "Unsupported data class: #{data.class}"
+    end
+  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

@@ -0,0 +1,63 @@
+module Charty
+  module TableAdapters
+    class ActiveRecordAdapter < BaseAdapter
+      TableAdapters.register(:active_record, self)
+
+      def self.supported?(data)
+        defined?(ActiveRecord::Relation) && data.is_a?(ActiveRecord::Relation)
+      end
+
+      def initialize(data)
+        @data = check_type(ActiveRecord::Relation, data, :data)
+        @column_names = @data.column_names.freeze
+        self.columns = Index.new(@column_names)
+        self.index = RangeIndex.new(0 ... length)
+      end
+
+      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_cache
+        if row
+          @columns_cache[resolve_column_index(column)][row]
+        else
+          column_data = @columns_cache[resolve_column_index(column)]
+          Vector.new(column_data, index: index, name: column)
+        end
+      end
+
+      private def resolve_column_index(column)
+        case column
+        when String, Symbol
+          index = column_names.index(column.to_s)
+          unless index
+            raise IndexError, "invalid column name: #{column.inspect}"
+          end
+          index
+        when Integer
+          column
+        else
+          message = "column must be String or Integer: #{column.inspect}"
+          raise ArgumentError, message
+        end
+      end
+
+      private def fetch_records
+        @columns_cache = @data.pluck(*column_names).transpose
+      end
+
+      private def check_type(type, data, name)
+        return data if data.is_a?(type)
+        raise TypeError, "#{name} must be a #{type}"
+      end
+    end
+  end
+end

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