charty 0.1.4.dev → 0.2.4

data/lib/charty/vector_adapters/narray_adapter.rb

@@ -0,0 +1,187 @@
+module Charty
+  module VectorAdapters
+    class NArrayAdapter < BaseAdapter
+      VectorAdapters.register(:narray, self)
+
+      extend Forwardable
+      include Enumerable
+
+      def self.supported?(data)
+        defined?(Numo::NArray) && data.is_a?(Numo::NArray)
+      end
+
+      def initialize(data)
+        @data = check_data(data)
+        self.index = index || RangeIndex.new(0 ... length)
+      end
+
+      def compare_data_equality(other)
+        case other
+        when ArrayAdapter, NArrayAdapter
+          data == other.data
+        when NumpyAdapter, PandasSeriesAdapter
+          other.compare_data_equality(self)
+        else
+          data == other.data.to_a
+        end
+      end
+
+      include NameSupport
+      include IndexSupport
+
+      # TODO: Reconsider the return value type of values_at
+      def values_at(*indices)
+        data[indices].to_a
+      end
+
+      def where(mask)
+        mask = check_mask_vector(mask)
+        case mask.data
+        when Numo::Bit
+          bits = mask.data
+          masked_data = data[bits]
+          masked_index = bits.where.map {|i| index[i] }.to_a
+        else
+          masked_data, masked_index = where_in_array(mask)
+          masked_data = data.class[*masked_data]
+        end
+        Charty::Vector.new(masked_data, index: masked_index, name: name)
+      end
+
+      def boolean?
+        case data
+        when Numo::Bit
+          true
+        when Numo::RObject
+          i, n = 0, data.size
+          while i < n
+            case data[i]
+            when nil, true, false
+              # do nothing
+            else
+              return false
+            end
+            i += 1
+          end
+          true
+        else
+          false
+        end
+      end
+
+      def numeric?
+        case data
+        when Numo::Bit,
+             Numo::RObject
+          false
+        else
+          true
+        end
+      end
+
+      def categorical?
+        false
+      end
+
+      def categories
+        nil
+      end
+
+      def unique_values
+        existence = {}
+        i, n = 0, data.size
+        unique = []
+        while i < n
+          x = data[i]
+          unless existence[x]
+            unique << x
+            existence[x] = true
+          end
+          i += 1
+        end
+        unique
+      end
+
+      def group_by(grouper)
+        case grouper
+        when Charty::Vector
+          # nothing to do
+        else
+          grouper = Charty::Vector.new(grouper)
+        end
+
+        group_keys = grouper.unique_values
+
+        case grouper.data
+        when Numo::NArray
+          grouper = grouper.data
+        else
+          grouper = Numo::NArray[*grouper.to_a]
+        end
+
+        group_keys.map { |g|
+          [g, Charty::Vector.new(data[grouper.eq(g)])]
+        }.to_h
+      end
+
+      def drop_na
+        case data
+        when Numo::DFloat, Numo::SFloat, Numo::DComplex, Numo::SComplex
+          Charty::Vector.new(data[~data.isnan])
+        when Numo::RObject
+          where_is_nan = data.isnan
+          values = []
+          i, n = 0, data.size
+          while i < n
+            x = data[i]
+            unless x.nil? || where_is_nan[i] == 1
+              values << x
+            end
+            i += 1
+          end
+          Charty::Vector.new(Numo::RObject[*values])
+        else
+          self
+        end
+      end
+
+      def eq(val)
+        Charty::Vector.new(data.eq(val),
+                           index: index,
+                           name: name)
+      end
+
+      def notnull
+        case data
+        when Numo::RObject
+          i, n = 0, length
+          notnull_data = Numo::Bit.zeros(n)
+          while i < n
+            notnull_data[i] = ! missing_value?(data[i])
+            i += 1
+          end
+        when ->(x) { x.respond_to?(:isnan) }
+          notnull_data = ~data.isnan
+        else
+          notnull_data = Numo::Bit.ones(length)
+        end
+        Charty::Vector.new(notnull_data, index: index, name: name)
+      end
+
+      def mean
+        data.mean(nan: true)
+      end
+
+      def stdev(population: false)
+        s = data.stddev(nan: true)
+        if population
+          # Numo::NArray does not support population standard deviation
+          n = data.isnan.sum
+          s * (n - 1) / n
+        else
+          s
+        end
+      end
+    end
+  end
+end

data/lib/charty/vector_adapters/nmatrix_adapter.rb

@@ -0,0 +1,37 @@
+module Charty
+  module VectorAdapters
+    class NMatrixAdapter < BaseAdapter
+      VectorAdapters.register(:nmatrix, self)
+
+      extend Forwardable
+      include Enumerable
+
+      def self.supported?(data)
+        defined?(NMatrix) && data.is_a?(NMatrix)
+      end
+
+      def initialize(data)
+        @data = check_data(data)
+        self.index = index || RangeIndex.new(0 ... length)
+      end
+
+      def compare_data_equality(other)
+        case other
+        when NMatrixAdapter
+          data == other.data
+        when ArrayAdapter, DaruVectorAdapter
+          data.to_a == other.data.to_a
+        when NArrayAdapter, NumpyAdapter, PandasSeriesAdapter
+          other.compare_data_equality(self)
+        else
+          data == other.data.to_a
+        end
+      end
+
+      include NameSupport
+      include IndexSupport
+
+      alias length size
+    end
+  end
+end

data/lib/charty/vector_adapters/numpy_adapter.rb

@@ -0,0 +1,168 @@
+module Charty
+  module VectorAdapters
+    class NumpyAdapter < BaseAdapter
+      VectorAdapters.register(:numpy, self)
+
+      def self.supported?(data)
+        return false unless defined?(Numpy::NDArray)
+        case data
+        when Numpy::NDArray
+          true
+        else
+          false
+        end
+      end
+
+      def initialize(data)
+        @data = check_data(data)
+        self.index = index || RangeIndex.new(0 ... length)
+      end
+
+      attr_reader :data
+
+      def_delegator :data, :size, :length
+
+      def compare_data_equality(other)
+        case other
+        when NumpyAdapter, PandasSeriesAdapter
+          Numpy.all(data == other.data)
+        when BaseAdapter
+          Numpy.all(data == other.data.to_a)
+        else
+          false
+        end
+      end
+
+      include NameSupport
+      include IndexSupport
+
+      def where(mask)
+        mask = check_mask_vector(mask)
+        case mask.data
+        when Numpy::NDArray,
+             ->(x) { defined?(Pandas::Series) && x.is_a?(Pandas::Series) }
+          mask_data = Numpy.asarray(mask.data, dtype: :bool)
+          masked_data = data[mask_data]
+          masked_index = mask_data.nonzero()[0].to_a.map {|i| index[i] }
+        else
+          masked_data, masked_index = where_in_array(mask)
+          masked_data = Numpy.asarray(masked_data, dtype: data.dtype)
+        end
+        Charty::Vector.new(masked_data, index: masked_index, name: name)
+      end
+
+      def each
+        return enum_for(__method__) unless block_given?
+
+        i, n = 0, data.size
+        while i < n
+          yield data[i]
+          i += 1
+        end
+      end
+
+      def empty?
+        data.size == 0
+      end
+
+      def boolean?
+        builtins = PyCall.builtins
+        case
+        when builtins.issubclass(data.dtype.type, Numpy.bool_)
+          true
+        when builtins.issubclass(data.dtype.type, Numpy.object_)
+          i, n = 0, data.size
+          while i < n
+            case data[i]
+            when nil, true, false
+              # do nothing
+            else
+              return false
+            end
+            i += 1
+          end
+          true
+        else
+          false
+        end
+      end
+
+      def numeric?
+        # TODO: Handle object array
+        PyCall.builtins.issubclass(data.dtype.type, PyCall.tuple([Numpy.number, Numpy.bool_]))
+      end
+
+      def categorical?
+        false
+      end
+
+      def categories
+        nil
+      end
+
+      def unique_values
+        Numpy.unique(data).to_a
+      end
+
+      def group_by(grouper)
+        case grouper
+        when Numpy::NDArray,
+             ->(x) { defined?(Pandas::Series) && x.is_a?(Pandas::Series) }
+          # Nothing todo
+        when Charty::Vector
+          case grouper.data
+          when Numpy::NDArray
+            grouper = grouper.data
+          else
+            grouper = Numpy.asarray(grouper.to_a)
+          end
+        else
+          grouper = Numpy.asarray(Array.try_convert(grouper))
+        end
+
+        group_keys = Numpy.unique(grouper).to_a
+        group_keys.map { |g|
+          [g, Charty::Vector.new(data[grouper == g])]
+        }.to_h
+      end
+
+      def drop_na
+        where_is_na = if numeric?
+                        Numpy.isnan(data)
+                      else
+                        (data == nil)
+                      end
+        Charty::Vector.new(data[Numpy.logical_not(where_is_na)])
+      end
+
+      def eq(val)
+        Charty::Vector.new((data == val),
+                           index: index,
+                           name: name)
+      end
+
+      def notnull
+        case
+        when PyCall.builtins.issubclass(data.dtype.type, Numpy.object_)
+          i, n = 0, length
+          notnull_data = Numpy::NDArray.new(n, dtype: :bool)
+          while i < n
+            notnull_data[i] = ! missing_value?(data[i])
+            i += 1
+          end
+        else
+          notnull_data = Numpy.isnan(data)
+        end
+        Charty::Vector.new(notnull_data, index: index, name: name)
+      end
+
+      def mean
+        Numpy.mean(data)
+      end
+
+      def stdev(population: false)
+        Numpy.std(data, ddof: population ? 0 : 1)
+      end
+    end
+  end
+end

data/lib/charty/vector_adapters/pandas_adapter.rb

@@ -0,0 +1,200 @@
+module Charty
+  module VectorAdapters
+    class PandasSeriesAdapter < BaseAdapter
+      VectorAdapters.register(:pandas_series, self)
+
+      def self.supported?(data)
+        return false unless defined?(Pandas::Series)
+        case data
+        when Pandas::Series
+          true
+        else
+          false
+        end
+      end
+
+      def initialize(data)
+        @data = check_data(data)
+      end
+
+      attr_reader :data
+
+      def_delegator :data, :size, :length
+
+      def index
+        PandasIndex.new(data.index)
+      end
+
+      def index=(new_index)
+        case new_index
+        when PandasIndex
+          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 PandasSeriesAdapter
+          return data.equals(other.data)
+        when NumpyAdapter
+          other = other.data
+        when NArrayAdapter
+          case other.data
+          when Numo::Bit
+            other = other.data.to_a
+            other.map! {|x| [false, true][x] }
+          else
+            other = other.data.to_a
+          end
+        when BaseAdapter
+          other = other.data.to_a
+        else
+          return false
+        end
+
+        data.equals(Pandas::Series.new(other, index: data.index))
+      end
+
+      def [](key)
+        case key
+        when Charty::Vector
+          where(key)
+        else
+          data[key]
+        end
+      end
+
+      def_delegators :data, :[]=, :to_a
+
+      def each
+        return enum_for(__method__) unless block_given?
+
+        i, n = 0, data.size
+        while i < n
+          yield data.iloc[i]
+          i += 1
+        end
+      end
+
+      def empty?
+        data.size == 0
+      end
+
+      # TODO: Reconsider the return value type of values_at
+      def values_at(*indices)
+        data.take(indices).to_a
+      end
+
+      def where(mask)
+        mask = check_mask_vector(mask)
+        case mask.data
+        when Numpy::NDArray,
+             ->(x) { defined?(Pandas::Series) && x.is_a?(Pandas::Series) }
+          mask_data = Numpy.asarray(mask.data, dtype: :bool)
+          masked_data = data[mask_data]
+          masked_index = mask_data.nonzero()[0].to_a.map {|i| index[i] }
+        else
+          masked_data, masked_index = where_in_array(mask)
+          masked_data = Pandas::Series.new(masked_data, dtype: data.dtype)
+        end
+        Charty::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.iloc[i]
+            masked_index << index[i]
+          end
+        end
+        return masked_data, masked_index
+      end
+
+      def boolean?
+        case
+        when Pandas.api.types.is_bool_dtype(data.dtype)
+          true
+        when Pandas.api.types.is_object_dtype(data.dtype)
+          data.isin([nil, false, true]).all()
+        else
+          false
+        end
+      end
+
+      def numeric?
+        Pandas.api.types.is_numeric_dtype(data.dtype)
+      end
+
+      def categorical?
+        Pandas.api.types.is_categorical_dtype(data.dtype)
+      end
+
+      def categories
+        data.cat.categories.to_a if categorical?
+      end
+
+      def unique_values
+        data.unique.to_a
+      end
+
+      def group_by(grouper)
+        case grouper
+        when Pandas::Series
+          group_keys = grouper.unique.to_a
+          groups = data.groupby(grouper)
+          group_keys.map {|g|
+            [g, Charty::Vector.new(groups.get_group(g))]
+          }.to_h
+        when Charty::Vector
+          case grouper.adapter
+          when self.class
+            group_by(grouper.data)
+          else
+            grouper = Pandas::Series.new(grouper.to_a)
+            group_by(grouper)
+          end
+        else
+          grouper = Pandas::Series.new(Array(grouper))
+          group_by(grouper)
+        end
+      end
+
+      def drop_na
+        Charty::Vector.new(data.dropna)
+      end
+
+      def eq(val)
+        Charty::Vector.new((data == val),
+                           index: index,
+                           name: name)
+      end
+
+      def notnull
+        Charty::Vector.new(data.notnull, index: index, name: name)
+      end
+
+      def mean
+        data.mean()
+      end
+
+      def stdev(population: false)
+        data.std(ddof: population ? 0 : 1)
+      end
+
+      def percentile(q)
+        q = q.map {|x| x / 100.0 }
+        data.quantile(q)
+      end
+    end
+  end
+end