red_amber 0.4.1 → 0.5.0

data/lib/red_amber/subframes.rb

@@ -10,6 +10,45 @@ module RedAmber
     using RefineArray
     using RefineArrayLike
 
+    # Entity to select sub-dataframes
+    class Selectors
+      attr_reader :selectors, :size, :sizes
+
+      def initialize(selectors)
+        @selectors = selectors
+        @size = selectors.size
+        @sizes = []
+      end
+
+      # Generic iterator method
+      def each
+        @selectors.each
+      end
+    end
+
+    # Boolean selectors of sub-dataframes
+    class Filters < Selectors
+      # Return sizes of filter
+      # @return [Array<Integer>]
+      #   sizes of each sub dataframes.
+      #   Counts true for each filter.
+      def sizes
+        @sizes = @selectors.map { |s| s.to_a.count { _1 } } # rubocop:disable Performance/Size
+      end
+    end
+
+    # Index selectors of sub-dataframes
+    class Indices < Selectors
+      # Return sizes of selector indices.
+      # @return [Array<Integer>]
+      #   sizes of each sub dataframes.
+      def sizes
+        @sizes = @selectors.map(&:size)
+      end
+    end
+
+    private_constant :Selectors, :Filters, :Indices
+
     class << self
       # Create SubFrames from a Group.
       #
@@ -61,7 +100,7 @@ module RedAmber
       # @since 0.4.0
       #
       def by_group(group)
-        SubFrames.new(group.dataframe, group.filters)
+        SubFrames.by_filters(group.dataframe, group.filters)
       end
 
       # Create a new SubFrames object from a DataFrame and an array of indices.
@@ -79,13 +118,8 @@ module RedAmber
       def by_indices(dataframe, subset_indices)
         instance = allocate
         instance.instance_variable_set(:@baseframe, dataframe)
-        enum =
-          Enumerator.new(subset_indices.size) do |y|
-            subset_indices.each do |i|
-              y.yield DataFrame.new_dataframe_with_schema(dataframe, dataframe.take(i))
-            end
-          end
-        instance.instance_variable_set(:@enum, enum)
+        instance.instance_variable_set(:@selectors, Indices.new(subset_indices))
+        instance.instance_variable_set(:@frames, [])
         instance
       end
 
@@ -105,13 +139,8 @@ module RedAmber
       def by_filters(dataframe, subset_filters)
         instance = allocate
         instance.instance_variable_set(:@baseframe, dataframe)
-        enum =
-          Enumerator.new(subset_filters.size) do |y|
-            subset_filters.each do |i|
-              y.yield DataFrame.new_dataframe_with_schema(dataframe, dataframe.filter(i))
-            end
-          end
-        instance.instance_variable_set(:@enum, enum)
+        instance.instance_variable_set(:@selectors, Filters.new(subset_filters))
+        instance.instance_variable_set(:@frames, [])
         instance
       end
 
@@ -130,18 +159,13 @@ module RedAmber
         case Array(dataframes)
         when [] || [nil]
           instance.instance_variable_set(:@baseframe, DataFrame.new)
+          instance.instance_variable_set(:@selectors, [])
           instance.instance_variable_set(:@frames, [])
-          enum = [].each
         else
-          enum =
-            Enumerator.new(dataframes.size) do |y|
-              dataframes.each do |i|
-                y.yield i
-              end
-            end
-          instance.instance_variable_set(:@baseframe, enum.lazy)
+          instance.instance_variable_set(:@baseframe, nil)
+          instance.instance_variable_set(:@selectors, nil)
+          instance.instance_variable_set(:@frames, dataframes)
         end
-        instance.instance_variable_set(:@enum, enum)
         instance
       end
 
@@ -261,40 +285,34 @@ module RedAmber
     #
     # @since 0.4.0
     #
-    def initialize(dataframe, subset_specifier = nil, &block)
+    def initialize(dataframe, selectors = nil, &block)
       unless dataframe.is_a?(DataFrame)
         raise SubFramesArgumentError, "not a DataFrame: #{dataframe}"
       end
 
       if block
-        unless subset_specifier.nil?
+        unless selectors.nil?
           raise SubFramesArgumentError, 'Must not specify both arguments and block.'
         end
 
-        subset_specifier = yield(dataframe)
+        selectors = yield(dataframe)
       end
 
-      if dataframe.empty? || subset_specifier.nil? || subset_specifier.empty?
+      if dataframe.empty? || selectors.nil? || selectors.size.zero? # rubocop:disable Style/ZeroLengthPredicate
         @baseframe = DataFrame.new
-        @frames = []
-        @enum = @frames.each
+        @selectors = Selectors.new([])
       else
-        @baseframe = nil
-        @enum =
-          Enumerator.new(subset_specifier.size) do |yielder|
-            subset_specifier.map do |i|
-              df =
-                if i.numeric?
-                  dataframe.take(i)
-                elsif i.boolean?
-                  dataframe.filter(i)
-                else
-                  raise SubFramesArgumentError, "illegal type: #{i}"
-                end
-              yielder.yield DataFrame.new_dataframe_with_schema(dataframe, df)
-            end
+        @baseframe = dataframe
+        @selectors =
+          if selectors.first.boolean?
+            Filters.new(selectors)
+          elsif selectors.first.numeric?
+            Indices.new(selectors)
+          else
+            raise SubFramesArgumentError, "illegal type: #{selectors}"
           end
       end
+      @frames = []
     end
 
     # Return concatenated SubFrames as a DataFrame.
@@ -305,11 +323,7 @@ module RedAmber
     # @since 0.4.0
     #
     def baseframe
-      if @baseframe.nil? || @baseframe.is_a?(Enumerator)
-        @baseframe = reduce(&:concatenate)
-      else
-        @baseframe
-      end
+      @baseframe ||= reduce(&:concatenate)
     end
     alias_method :concatenate, :baseframe
     alias_method :concat, :baseframe
@@ -384,7 +398,19 @@ module RedAmber
     def each(&block)
       return enum_for(__method__) { size } unless block
 
-      frames.each(&block)
+      if @selectors
+        @selectors.each.with_index do |selector, i|
+          if i < @frames.size
+            yield @frames[i]
+          else
+            frame = get_subframe(selector)
+            @frames << frame
+            yield frame
+          end
+        end
+      else
+        @frames.each(&block)
+      end
       nil
     end
 
@@ -916,6 +942,26 @@ module RedAmber
     #
     define_subframable_method :filter_map
 
+    # Return 0...num sub-dataframes in self.
+    #
+    # @param num [Integer, Float]
+    #   num of sub-dataframes to pick up. `num`` must be positive or zero.
+    # @return [SubFrames]
+    #   A new SubFrames.
+    #   If n == 0, it returns empty SubFrames.
+    #   If n >= size, it returns self.
+    # @since 0.4.2
+    #
+    def take(num)
+      if num.zero?
+        SubFrames.new(DataFrame.new, [])
+      elsif num >= size
+        self
+      else
+        SubFrames.by_dataframes(frames(num))
+      end
+    end
+
     # Number of subsets.
     #
     # @return [Integer]
@@ -923,7 +969,12 @@ module RedAmber
     # @since 0.4.0
     #
     def size
-      @size ||= @enum.size
+      @size ||=
+        if @selectors
+          @selectors.size
+        else
+          @frames.size
+        end
     end
 
     # Size list of subsets.
@@ -933,7 +984,12 @@ module RedAmber
     # @since 0.4.0
     #
     def sizes
-      @sizes ||= @enum.map(&:size)
+      @sizes ||=
+        if @selectors
+          @selectors.sizes
+        else
+          @frames.map(&:size)
+        end
     end
 
     # Indices at the top of each sub DataFrames.
@@ -945,10 +1001,17 @@ module RedAmber
     # @since 0.4.0
     #
     def offset_indices
-      sum = 0
-      sizes.map do |size|
-        sum += size
-        sum - size
+      case @selectors
+      when Filters
+        @selectors.selectors.map do |selector|
+          selector.each.with_index.find { |x, _| x }[1]
+        end
+      else # Indices, nil
+        sum = 0
+        sizes.map do |size|
+          sum += size
+          sum - size
+        end
       end
     end
 
@@ -965,11 +1028,11 @@ module RedAmber
     # Test if self has only one subset and it is comprehensive.
     #
     # @return [true, false]
-    #   true if only member of self is equal to universal DataFrame.
+    #   true if the only member of self is equal to universal DataFrame.
     # @since 0.4.0
     #
     def universal?
-      size == 1 && @enum.first == baseframe
+      size == 1 && first == @baseframe
     end
 
     # Return string representation of self.
@@ -1012,7 +1075,7 @@ module RedAmber
     #
     # @since 0.4.0
     #
-    def to_s(limit: 16)
+    def to_s(limit: 5)
       _to_s(limit: limit)
     end
 
@@ -1064,10 +1127,10 @@ module RedAmber
     #
     # @since 0.4.0
     #
-    def inspect(limit: 16)
+    def inspect(limit: 5)
       shape =
-        if @baseframe.is_a?(Enumerator)
-          "Enumerator::Lazy:size=#{@baseframe.size}"
+        if @baseframe.nil?
+          '(Not prepared)'
         else
           baseframe.shape_str(with_id: true)
         end
@@ -1079,14 +1142,51 @@ module RedAmber
         "---\n#{_to_s(limit: limit, with_id: true)}"
     end
 
+    # Return an Array of sub DataFrames
+    #
+    # @overload frames
+    #   Returns all sub dataframes.
+    #
+    #   @return [Array<DataFrame>]
+    #     sub DataFrames.
+    #
+    # @overload frames(n_frames)
+    #   Returns partial sub dataframes.
+    #
+    #   @param n_frames [Integer]
+    #     num of dataframes to retrieve.
+    #   @return [Array<DataFrame>]
+    #     sub DataFrames.
+    #
+    # @since 0.4.2
+    #
+    def frames(n_frames = nil)
+      n_frames = size if n_frames.nil?
+
+      if @frames.size < n_frames
+        @frames = each.take(n_frames)
+      else
+        @frames.take(n_frames)
+      end
+    end
+
     private
 
-    def frames
-      @frames ||= @enum.to_a
+    # Get sub dataframe specified by 'selector'
+    def get_subframe(selector)
+      df =
+        case @selectors
+        when Filters
+          @baseframe.filter(selector)
+        when Indices
+          @baseframe.take(selector)
+        end
+      DataFrame.new_dataframe_with_schema(@baseframe, df)
     end
 
-    def _to_s(limit: 16, with_id: false)
-      a = take(limit).map do |df|
+    # Subcontractor of to_s
+    def _to_s(limit: 5, with_id: false)
+      a = each.take(limit).map do |df|
         if with_id
           "#<#{df.shape_str(with_id: with_id)}>\n" \
             "#{df.to_s(head: 2, tail: 2)}"

data/lib/red_amber/vector.rb

@@ -10,21 +10,54 @@ module RedAmber
     include ArrowFunction
     include VectorUpdatable
     include VectorSelectable
+    include VectorStringFunction
 
     using RefineArrayLike
 
-    # Quicker constructor of Vector.
+    # Entity of Vector.
     #
-    # @param arrow_array [Arrow::Array]
-    #   Arrow::Array object to have in the Vector.
-    # @return [Vector]
-    #   created Vector.
-    # @note This method doesn't check argment type.
+    # @return [Arrow::Array]
+    #
+    attr_reader :data
+    alias_method :to_arrow_array, :data
+
+    # Associated key name when self is in a DataFrame.
+    #
+    # Default Vector is 'head-less' (key-less).
+    # @return [Symbol]
     #
-    def self.create(arrow_array)
-      instance = allocate
-      instance.instance_variable_set(:@data, arrow_array)
-      instance
+    attr_accessor :key
+
+    class << self
+      # Create a Vector (calling `.new`).
+      #
+      # @param (see #initialize)
+      # @return (see #initialize)
+      # @example Create an empty Vector.
+      #   Vector[]
+      #   # =>
+      #   #<RedAmber::Vector(:string, size=0):0x000000000000e2cc>
+      #   []
+      #
+      # @since 0.5.0
+      #
+      def [](...)
+        new(...)
+      end
+
+      # Quicker constructor of Vector.
+      #
+      # @param arrow_array [Arrow::Array]
+      #   Arrow::Array object to have in the Vector.
+      # @return [Vector]
+      #   created Vector.
+      # @note This method doesn't check argment type.
+      #
+      def create(arrow_array)
+        instance = allocate
+        instance.instance_variable_set(:@data, arrow_array)
+        instance
+      end
     end
 
     # Create a Vector.
@@ -51,20 +84,6 @@ module RedAmber
         end
     end
 
-    # Entity of Vector.
-    #
-    # @return [Arrow::Array]
-    #
-    attr_reader :data
-    alias_method :to_arrow_array, :data
-
-    # Associated key name when self is in a DataFrame.
-    #
-    # Default Vector is 'head-less' (key-less).
-    # @return [Symbol]
-    #
-    attr_accessor :key
-
     # Return other as a Vector which is same data type as self.
     #
     # @param other [Vector, Array, Arrow::Array, Arrow::ChunkedArray]

data/lib/red_amber/vector_aggregation.rb

@@ -161,6 +161,22 @@ module RedAmber
     #
     define_unary_aggregation :min_max
 
+    # Compute the 1 most common values and their respective
+    #   occurence counts.
+    #
+    # @note Self must be a numeric or a boolean Vector.
+    # @note ModeOptions are not supported in 0.5.0 .
+    #   Only one mode value is returned.
+    # @api private
+    # @return [Hash{'mode'=>mode, 'count'=>count}]
+    #    mode and count of self in an array.
+    # @since 0.5.0
+    #
+    def mode
+      datum = find(:mode).execute([data])
+      datum.value.to_a.first
+    end
+
     # Compute product value of self.
     #
     # @note Self must be a numeric Vector.
@@ -241,6 +257,16 @@ module RedAmber
     #     - nearest: returns i or j, whichever is closer.
     #     - midpoint: returns (i + j) / 2.
 
+    # Get a non-nil element in self.
+    #
+    # @return [Object, nil]
+    #   first non-nil value detected. If all elements are nil, return nil.
+    # @since 0.5.0
+    #
+    def one
+      each.find { !_1.nil? }
+    end
+
     # Returns a quantile value.
     # - 0.5 quantile (median) is returned by default.
     # - Or return quantile for specified probability (prob).

data/lib/red_amber/vector_binary_element_wise.rb

@@ -236,7 +236,6 @@ module RedAmber
     #   division of self by other.
     #
     define_binary_element_wise :divide
-    alias_method :div, :divide
     alias_method :'/', :divide
 
     # Divide the arguments element-wise.
@@ -248,21 +247,21 @@ module RedAmber
 
     # Returns element-wise modulo.
     #
-    # This is equivalent to `self-other*(self/other).floor`.
-    # @param other [Vector, numeric]
-    #   other numeric Vector or numeric scalar.
+    # This is equivalent to `self-divisor*(self/divisor).floor`.
+    # @note Same behavior as Ruby.
+    # @param divisor [Vector, numeric]
+    #   divisor numeric Vector or numeric scalar.
     # @return [Vector]
-    #   modulo of dividing self by other.
+    #   modulo of dividing self by divisor.
     #
-    def modulo(other)
-      other = other.data if other.is_a?(Vector)
-      d = find(:divide).execute([data, other])
+    def modulo(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      d = find(:divide).execute([data, divisor])
       d = find(:floor).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
-      m = find(:multiply).execute([d, other])
+      m = find(:multiply).execute([d, divisor])
       datum = find(:subtract).execute([data, m])
       Vector.create(datum.value)
     end
-    alias_method :mod, :modulo
     alias_method :'%', :modulo
 
     # Returns element-wise modulo.
@@ -270,11 +269,11 @@ module RedAmber
     # This function is a overflow-checking variant of #modulo.
     # @return (see #modulo)
     #
-    def modulo_checked(other)
-      other = other.data if other.is_a?(Vector)
-      d = find(:divide_checked).execute([data, other])
+    def modulo_checked(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      d = find(:divide_checked).execute([data, divisor])
       d = find(:floor).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
-      m = find(:multiply_checked).execute([d, other])
+      m = find(:multiply_checked).execute([d, divisor])
       datum = find(:subtract_checked).execute([data, m])
       Vector.create(datum.value)
     end
@@ -323,27 +322,57 @@ module RedAmber
 
     # Returns element-wise quotient by double Vector.
     #
-    # @param other [Vector, numeric]
-    #   other numeric Vector or numeric scalar.
+    # @param divisor [Vector, numeric]
+    #   divisor numeric Vector or numeric scalar.
     # @return [Vector]
-    #   quotient of dividing self by other.
+    #   quotient of dividing self by divisor.
     #
-    def quotient(other)
-      other = other.data if other.is_a?(Vector)
-      datum = find(:divide).execute([Arrow::DoubleArray.new(data), other])
+    def fdiv(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      datum = find(:divide).execute([Arrow::DoubleArray.new(data), divisor])
       Vector.create(datum.value)
     end
-    alias_method :quo, :quotient
-    alias_method :fdiv, :quotient
 
     # Returns element-wise quotient by double Vector.
     #
     # This function is a overflow-checking variant of #quotient.
     # @return (see #quotient)
     #
-    def quotient_checked(other)
-      other = other.data if other.is_a?(Vector)
-      datum = find(:divide_checked).execute([Arrow::DoubleArray.new(data), other])
+    def fdiv_checked(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      datum = find(:divide_checked).execute([Arrow::DoubleArray.new(data), divisor])
+      Vector.create(datum.value)
+    end
+
+    # Returns element-wise remainder.
+    #
+    # This is equivalent to `self-divisor*(self/divisor).trunc`.
+    # @note Same behavior as Ruby's remainder.
+    # @param divisor [Vector, numeric]
+    #   divisor numeric Vector or numeric scalar.
+    # @return [Vector]
+    #   modulo of dividing self by divisor.
+    #
+    def remainder(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      d = find(:divide).execute([data, divisor])
+      d = find(:trunc).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
+      m = find(:multiply).execute([d, divisor])
+      datum = find(:subtract).execute([data, m])
+      Vector.create(datum.value)
+    end
+
+    # Returns element-wise modulo.
+    #
+    # This function is a overflow-checking variant of #modulo.
+    # @return (see #modulo)
+    #
+    def remainder_checked(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      d = find(:divide_checked).execute([data, divisor])
+      d = find(:trunc).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
+      m = find(:multiply_checked).execute([d, divisor])
+      datum = find(:subtract_checked).execute([data, m])
       Vector.create(datum.value)
     end