charty 0.2.3 → 0.2.4

data/lib/charty/vector.rb

@@ -0,0 +1,69 @@
+require "forwardable"
+
+module Charty
+  class Vector
+    extend Forwardable
+    include Enumerable
+
+    def self.try_convert(obj)
+      case obj
+      when self
+        obj
+      else
+        if VectorAdapters.find_adapter_class(obj, exception: false)
+          new(obj)
+        end
+      end
+    end
+
+    def initialize(data, index: nil, name: nil)
+      adapter_class = VectorAdapters.find_adapter_class(data)
+      @adapter = adapter_class.new(data)
+      self.index = index unless index.nil?
+      self.name = name unless name.nil?
+    end
+
+    attr_reader :adapter
+
+    def_delegators :adapter, :data
+    def_delegators :adapter, :index, :index=
+    def_delegators :adapter, :==, :[], :[]=
+
+    def_delegators :adapter, :length
+    def_delegators :adapter, :name, :name=
+
+    alias size length
+
+    def_delegators :adapter, :to_a
+    def_delegators :adapter, :each
+    def_delegators :adapter, :empty?
+
+    def_delegators :adapter, :boolean?, :numeric?, :categorical?
+    def_delegators :adapter, :categories
+    def_delegators :adapter, :unique_values
+    def_delegators :adapter, :group_by
+    def_delegators :adapter, :drop_na
+    def_delegators :adapter, :values_at
+
+    def_delegators :adapter, :eq, :notnull
+
+    alias completecases notnull
+
+    def_delegators :adapter, :mean, :stdev
+
+    # TODO: write test
+    def categorical_order(order=nil)
+      if order.nil?
+        case
+        when categorical?
+          order = categories
+        else
+          order = unique_values.compact
+          order.sort! if numeric?
+        end
+        order.compact!
+      end
+      order
+    end
+  end
+end

data/lib/charty/vector_adapters.rb

@@ -0,0 +1,183 @@
+require "forwardable"
+
+module Charty
+  module VectorAdapters
+    class UnsupportedVectorData < StandardError; end
+
+    @adapters = {}
+
+    def self.register(name, adapter_class)
+      @adapters[name] = adapter_class
+    end
+
+    def self.find_adapter_class(data, exception: true)
+      @adapters.each_value do |adapter_class|
+        return adapter_class if adapter_class.supported?(data)
+      end
+      if exception
+        raise UnsupportedVectorData, "Unsupported vector data (#{data.class})"
+      end
+    end
+
+    class BaseAdapter
+      extend Forwardable
+      include Enumerable
+      include MissingValueSupport
+
+      def self.adapter_name
+        name[/:?(\w+)Adapter\z/, 1]
+      end
+
+      private def check_data(data)
+        return data if self.class.supported?(data)
+        raise UnsupportedVectorData, "Unsupported vector data (#{data.class})"
+      end
+
+      attr_reader :data
+
+      def_delegators :data, :length, :size
+
+      def ==(other)
+        case other.adapter
+        when BaseAdapter
+          return false if other.index != index
+          if respond_to?(:compare_data_equality)
+            compare_data_equality(other.adapter)
+          elsif other.adapter.respond_to?(:compare_data_equality)
+            other.adapter.compare_data_equality(self)
+          else
+            case other.adapter
+            when self.class
+              data == other.data
+            else
+              false
+            end
+          end
+        else
+          super
+        end
+      end
+
+      def_delegators :data, :[], :[]=
+      def_delegators :data, :each, :to_a, :empty?
+
+      def where_in_array(mask)
+        mask = check_mask_vector(mask)
+        masked_data = []
+        masked_index = []
+        mask.each_with_index do |f, i|
+          case f
+          when true, 1
+            masked_data << data[i]
+            masked_index << index[i]
+          end
+        end
+        return masked_data, masked_index
+      end
+
+      private def check_mask_vector(mask)
+        # ensure mask is boolean vector
+        case mask
+        when Charty::Vector
+          unless mask.boolean?
+            raise ArgumentError, "Unable to lookup items by a nonboolean vector"
+          end
+          mask
+        else
+          Charty::Vector.new(mask)
+        end
+      end
+
+      def mean
+        Statistics.mean(data)
+      end
+
+      def stdev(population: false)
+        Statistics.stdev(data, population: population)
+      end
+    end
+
+    module NameSupport
+      attr_reader :name
+
+      def name=(value)
+        @name = check_name(value)
+      end
+
+      private def check_name(value)
+        value = String.try_convert(value) || value
+        case value
+        when String, Symbol
+          value
+        else
+          raise ArgumentError,
+                "name must be a String or a Symbol (#{value.class} is given)"
+        end
+      end
+    end
+
+    module IndexSupport
+      attr_reader :index
+
+      def [](key)
+        case key
+        when Charty::Vector
+          where(key)
+        else
+          super(key_to_loc(key))
+        end
+      end
+
+      def []=(key, val)
+        super(key_to_loc(key), val)
+      end
+
+      private def key_to_loc(key)
+        loc = self.index.loc(key)
+        if loc.nil?
+          if key.respond_to?(:to_int)
+            loc = key.to_int
+          else
+            raise KeyError.new("key not found: %p" % key,
+                               receiver: __method__, key: key)
+          end
+        end
+        loc
+      end
+
+      def index=(values)
+        @index = check_and_convert_index(values, :index, length)
+      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
+
+require_relative "vector_adapters/array_adapter"
+require_relative "vector_adapters/daru_adapter"
+require_relative "vector_adapters/narray_adapter"
+require_relative "vector_adapters/nmatrix_adapter"
+require_relative "vector_adapters/numpy_adapter"
+require_relative "vector_adapters/pandas_adapter"

data/lib/charty/vector_adapters/array_adapter.rb

@@ -0,0 +1,109 @@
+require "date"
+
+module Charty
+  module VectorAdapters
+    class ArrayAdapter < BaseAdapter
+      VectorAdapters.register(:array, self)
+
+      extend Forwardable
+      include Enumerable
+
+      def self.supported?(data)
+        case data
+        when Array
+          case data[0]
+          when Numeric, String, Time, Date, DateTime, true, false, nil
+            true
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+
+      def initialize(data, index: nil)
+        @data = check_data(data)
+        self.index = index || RangeIndex.new(0 ... length)
+      end
+
+      include NameSupport
+      include IndexSupport
+
+      # TODO: Reconsider the return value type of values_at
+      def_delegators :data, :values_at
+
+      def where(mask)
+        masked_data, masked_index = where_in_array(mask)
+        Charty::Vector.new(masked_data, index: masked_index, name: name)
+      end
+
+      def first_nonnil
+        data.drop_while(&:nil?).first
+      end
+
+      def boolean?
+        case first_nonnil
+        when true, false
+          true
+        else
+          false
+        end
+      end
+
+      def numeric?
+        case first_nonnil
+        when Numeric
+          true
+        else
+          false
+        end
+      end
+
+      def categorical?
+        false
+      end
+
+      def categories
+        nil
+      end
+
+      def_delegator :data, :uniq, :unique_values
+
+      def group_by(grouper)
+        groups = data.each_index.group_by {|i| grouper[i] }
+        groups.map { |g, vals|
+          vals.collect! {|i| self[i] }
+          [g, Charty::Vector.new(vals)]
+        }.to_h
+      end
+
+      def drop_na
+        if numeric?
+          Charty::Vector.new(data.reject { |x|
+            case x
+            when Float
+              x.nan?
+            else
+              x.nil?
+            end
+          })
+        else
+          Charty::Vector.new(data.compact)
+        end
+      end
+
+      def eq(val)
+        Charty::Vector.new(data.map {|x| x == val },
+                           index: index,
+                           name: name)
+      end
+
+      def notnull
+        Charty::Vector.new(data.map {|x| ! missing_value?(x) },
+                           index: index,
+                           name: name)
+      end
+    end
+  end
+end

data/lib/charty/vector_adapters/daru_adapter.rb

@@ -0,0 +1,171 @@
+module Charty
+  module VectorAdapters
+    class DaruVectorAdapter < BaseAdapter
+      VectorAdapters.register(:daru_vector, self)
+
+      def self.supported?(data)
+        defined?(Daru::Vector) && data.is_a?(Daru::Vector)
+      end
+
+      def initialize(data)
+        @data = check_data(data)
+      end
+
+      def_delegator :data, :size, :length
+
+      def index
+        DaruIndex.new(data.index)
+      end
+
+      def index=(new_index)
+        case new_index
+        when DaruIndex
+          data.index = new_index.values
+        when Index
+          data.index = new_index.to_a
+        else
+          data.index = new_index
+        end
+      end
+
+      def_delegators :data, :name, :name=
+
+      def compare_data_equality(other)
+        case other
+        when DaruVectorAdapter
+          data == other.data
+        when ArrayAdapter
+          data.to_a == other.data
+        when NArrayAdapter, NMatrixAdapter, NumpyAdapter, PandasSeriesAdapter
+          other.compare_data_equality(self)
+        else
+          data == other.data.to_a
+        end
+      end
+
+      def [](key)
+        case key
+        when Charty::Vector
+          where(key)
+        else
+          data[key]
+        end
+      end
+
+      def_delegators :data, :[]=, :to_a
+
+      def values_at(*indices)
+        indices.map {|i| data[i] }
+      end
+
+      def where(mask)
+        masked_data, masked_index = where_in_array(mask)
+        Charty::Vector.new(Daru::Vector.new(masked_data, index: masked_index), name: name)
+      end
+
+      def where_in_array(mask)
+        mask = check_mask_vector(mask)
+        masked_data = []
+        masked_index = []
+        mask.each_with_index do |f, i|
+          case f
+          when true, 1
+            masked_data << data[i]
+            masked_index << data.index.key(i)
+          end
+        end
+        return masked_data, masked_index
+      end
+
+      def first_nonnil
+        data.drop_while(&:nil?).first
+      end
+
+      def boolean?
+        case
+        when numeric?, categorical?
+          false
+        else
+          case first_nonnil
+          when true, false
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def_delegators :data, :numeric?
+      def_delegator :data, :category?, :categorical?
+
+      def categories
+        data.categories.compact if categorical?
+      end
+
+      def unique_values
+        data.uniq.to_a
+      end
+
+      def group_by(grouper)
+        case grouper
+        when Daru::Vector
+          if grouper.category?
+            # TODO: A categorical Daru::Vector cannot perform group_by well
+            grouper = Daru::Vector.new(grouper.to_a)
+          end
+          groups = grouper.group_by.groups
+          groups.map { |g, indices|
+            [g.first, Charty::Vector.new(data[*indices])]
+          }.to_h
+        when Charty::Vector
+          case grouper.data
+          when Daru::Vector
+            return group_by(grouper.data)
+          else
+            return group_by(Daru::Vector.new(grouper.to_a))
+          end
+        else
+          return group_by(Charty::Vector.new(grouper))
+        end
+      end
+
+      def drop_na
+        values = data.reject do |x|
+          case
+          when x.nil?,
+               x.respond_to?(:nan?) && x.nan?
+            true
+          else
+            false
+          end
+        end
+        Charty::Vector.new(Daru::Vector.new(values))
+      end
+
+      def eq(val)
+        Charty::Vector.new(data.eq(val).to_a,
+                           index: data.index.to_a,
+                           name: name)
+      end
+
+      def notnull
+        notnull_data = data.map {|x| ! missing_value?(x) }
+        Charty::Vector.new(notnull_data, index: data.index.to_a, name: name)
+      end
+
+      def_delegator :data, :mean
+
+      def stdev(population: false)
+        if population
+          data.standard_deviation_sample
+        else
+          data.standard_deviation_population
+        end
+      end
+
+      def percentile(q)
+        data.linear_percentile(q)
+      end
+    end
+  end
+end