charty 0.1.5.dev → 0.2.5

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

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