red_amber 0.1.5 → 0.1.8

data/lib/red_amber/data_frame_helper.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module RedAmber
-  # mix-in for the class DataFrame
-  module DataFrameHelper
-    private
-
-    def expand_range(args)
-      ary = args.each_with_object([]) do |e, a|
-        e.is_a?(Range) ? a.concat(normalized_array(e)) : a.append(e)
-      end
-      ary.map do |e|
-        if e.is_a?(Integer) && e.negative?
-          e + size
-        else
-          e
-        end
-      end
-    end
-
-    def normalized_array(range)
-      both_end = [range.begin, range.end]
-      both_end[1] -= 1 if range.exclude_end? && range.end.is_a?(Integer)
-
-      if both_end.any?(Integer) || both_end.all?(&:nil?)
-        if both_end.any? { |e| e&.>=(size) || e&.<(-size) }
-          raise DataFrameArgumentError, "Index out of range: #{range} for 0..#{size - 1}"
-        end
-
-        (0...size).to_a[range]
-      else
-        range.to_a
-      end
-    end
-
-    def out_of_range?(indeces)
-      indeces.max >= size || indeces.min < -size
-    end
-
-    def integers?(enum)
-      enum.all?(Integer)
-    end
-
-    def sym_or_str?(enum)
-      enum.all? { |e| e.is_a?(Symbol) || e.is_a?(String) }
-    end
-
-    def booleans?(enum)
-      enum.all? { |e| e.is_a?(TrueClass) || e.is_a?(FalseClass) || e.is_a?(NilClass) }
-    end
-
-    def create_dataframe_from_vector(key, vector)
-      DataFrame.new(key => vector.data)
-    end
-
-    def select_obs_by_boolean(array)
-      DataFrame.new(@table.filter(array))
-    end
-
-    def keys_by_booleans(booleans)
-      keys.select.with_index { |_, i| booleans[i] }
-    end
-  end
-end

data/lib/red_amber/data_frame_observation_operation.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module RedAmber
-  # mix-ins for the class DataFrame
-  module DataFrameObservationOperation
-    # slice and select some observations to create sub DataFrame
-    def slice(*args, &block)
-      slicer = args
-      if block
-        raise DataFrameArgumentError, 'Must not specify both arguments and block.' unless args.empty?
-
-        slicer = instance_eval(&block)
-      end
-      slicer = [slicer].flatten
-      return remove_all_values if slicer.empty? || slicer[0].nil?
-
-      # filter with same length
-      booleans = nil
-      if slicer[0].is_a?(Vector) || slicer[0].is_a?(Arrow::BooleanArray)
-        booleans = slicer[0].to_a
-      elsif slicer.size == size && booleans?(slicer)
-        booleans = slicer
-      end
-      return select_obs_by_boolean(booleans) if booleans
-
-      # filter with indexes
-      slicer = expand_range(slicer)
-      return map_indices(*slicer) if integers?(slicer)
-
-      raise DataFrameArgumentError, "Invalid argument #{args}"
-    end
-
-    # remove selected observations to create sub DataFrame
-    def remove(*args, &block)
-      remover = args
-      if block
-        raise DataFrameArgumentError, 'Must not specify both arguments and block.' unless args.empty?
-
-        remover = instance_eval(&block)
-      end
-      remover = [remover].flatten
-
-      return self if remover.empty?
-
-      # filter with same length
-      booleans = nil
-      if remover[0].is_a?(Vector) || remover[0].is_a?(Arrow::BooleanArray)
-        booleans = remover[0].to_a
-      elsif remover.size == size && booleans?(remover)
-        booleans = remover
-      end
-      if booleans
-        inverted = booleans.map(&:!)
-        return select_obs_by_boolean(inverted)
-      end
-
-      # filter with indexes
-      slicer = indexes.to_a - expand_range(remover)
-      return remove_all_values if slicer.empty?
-      return map_indices(*slicer) if integers?(slicer)
-
-      raise DataFrameArgumentError, "Invalid argument #{args}"
-    end
-
-    def remove_nil
-      func = Arrow::Function.find(:drop_null)
-      DataFrame.new(func.execute([table]).value)
-    end
-    alias_method :drop_nil, :remove_nil
-
-    def group(aggregating_keys, func, target_keys)
-      t = table.group(*aggregating_keys)
-      RedAmber::DataFrame.new(t.send(func, *target_keys))
-    end
-
-    private
-
-    # return a DataFrame with same keys as self without values
-    def remove_all_values
-      DataFrame.new(keys.each_with_object({}) { |key, h| h[key] = [] })
-    end
-  end
-end

data/lib/red_amber/vector_compensable.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-# Available functions in Arrow are shown by `Arrow::Function.all.map(&:name)`
-# reference: https://arrow.apache.org/docs/cpp/compute.html
-
-module RedAmber
-  # mix-ins for class Vector
-  # Functions to make up some data (especially missing) for new data.
-  module VectorCompensable
-    # [Ternary]: replace_with(booleans, replacements) => vector
-    # Replace items selected with a boolean mask
-    #
-    # (from Arrow C++ inline doc.)
-    # Given an array and a boolean mask (either scalar or of equal length),
-    # along with replacement values (either scalar or array),
-    # each element of the array for which the corresponding mask element is
-    # true will be replaced by the next value from the replacements,
-    # or with null if the mask is null.
-    # Hence, for replacement arrays, len(replacements) == sum(mask == true).
-
-    def replace_with(booleans, replacements = nil)
-      specifier =
-        if booleans.is_a?(Arrow::BooleanArray)
-          booleans
-        elsif booleans.is_a?(Vector) && booleans.boolean?
-          booleans.data
-        elsif booleans.is_a?(Array) && booleans?(booleans)
-          Arrow::BooleanArray.new(booleans)
-        else
-          raise VectorTypeError, 'Not a valid type'
-        end
-      raise VectorArgumentError, 'Booleans size unmatch' if specifier.length != size
-      raise VectorArgumentError, 'Booleans not have any `true`' unless specifier.any?
-
-      r = Array(replacements) # scalar to [scalar]
-      r = [nil] if r.empty?
-
-      replacer =
-        if r.size == 1
-          case replacements
-          when Arrow::Array then replacements
-          when Vector then replacements.data
-          else
-            Arrow::Array.new(r * specifier.to_a.count(true)) # broadcast
-          end
-        else
-          Arrow::Array.new(r)
-        end
-      replacer = data.class.new(replacer) if replacer.uniq == [nil]
-
-      raise VectorArgumentError, 'Replacements size unmatch' if Array(specifier).count(true) != replacer.length
-
-      values = replacer.class.new(data)
-
-      datum = find('replace_with_mask').execute([values, specifier, replacer])
-      take_out_element_wise(datum)
-    end
-
-    # (related functions)
-    # fill_null_backward, fill_null_forward
-
-    private
-
-    def booleans?(enum)
-      enum.all? { |e| e.is_a?(TrueClass) || e.is_a?(FalseClass) || e.is_a?(NilClass) }
-    end
-  end
-end