charty 0.2.0 → 0.2.6

data/lib/charty/vector_adapters/array_adapter.rb

@@ -0,0 +1,101 @@
+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
+
+      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| Util.missing?(x) })
+        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| ! Util.missing?(x) },
+                           index: index,
+                           name: name)
+      end
+    end
+  end
+end

data/lib/charty/vector_adapters/daru_adapter.rb

@@ -0,0 +1,163 @@
+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.at(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 {|x| Util.missing?(x) }
+        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| ! Util.missing?(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,182 @@
+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
+
+      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] = ! Util.missing?(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