Module: RedAmber::VectorSelectable

Included in:
Vector
Defined in:
lib/red_amber/vector_selectable.rb

Overview

mix-in for class Vector

Functions to select some data.

Instance Method Summary collapse

Instance Method Details

#[](*args) {|Array<Numeric, true, false, nil>, Vector| ... } ⇒ scalar, Array

Select elements in the self by indices or booleans.

Parameters:

  • args (Array<Numeric, true, false, nil>, Vector) —

    specifier.

Yields:

  • (Array<Numeric, true, false, nil>, Vector) —

    specifier.

Returns:

  • (scalar, Array) —

    returns scalar or array.

Raises:



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/red_amber/vector_selectable.rb', line 94

def [](*args)
  array =
    case args
    in [Vector => v]
      return scalar_or_array(take_by_vector(v)) if v.numeric?
      return scalar_or_array(filter_by_array(v.data)) if v.boolean?

      raise VectorTypeError, "Argument must be numeric or boolean: #{args}"
    in [Arrow::BooleanArray => ba]
      return scalar_or_array(filter_by_array(ba))
    in []
      return nil
    in [Arrow::Array => arrow_array]
      arrow_array
    in [Range => r]
      Arrow::Array.new(parse_range(r, size))
    else
      Arrow::Array.new(args.flatten)
    end

  return scalar_or_array(filter_by_array(array)) if array.boolean?

  vector = Vector.new(array)
  return scalar_or_array(take_by_vector(vector)) if vector.numeric?

  raise VectorArgumentError, "Invalid argument: #{args}"
end

#drop_nil ⇒ Object 



142
143
144
145
 
# File 'lib/red_amber/vector_selectable.rb', line 142

def drop_nil
  datum = find(:drop_null).execute([data])
  Vector.create(datum.value)
end

#filter(*booleans) {|Array<true, false, nil>, Vector| ... } ⇒ Vector Also known as: select, find_all

Select elements in the self by booleans.

Parameters:

  • booleans (Array<true, false, nil>, Vector) —

    booleans.

Yields:

  • (Array<true, false, nil>, Vector) —

    booleans.

Returns:

  • (Vector) —

    Vector by selected elements.

    TODO: support for the option ‘null_selection_behavior: :drop`



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/red_amber/vector_selectable.rb', line 55

def filter(*booleans, &block)
  if block
    unless booleans.empty?
      raise VectorArgumentError, 'Must not specify both arguments and block.'
    end

    booleans = [yield]
  end

  case booleans
  in [Vector => v]
    raise VectorTypeError, 'Argument is not a boolean.' unless v.boolean?

    Vector.create(filter_by_array(v.data))
  in [Arrow::BooleanArray => ba]
    Vector.create(filter_by_array(ba))
  in []
    Vector.new
  else
    booleans.flatten!
    a = Arrow::Array.new(booleans)
    if a.boolean?
      Vector.create(filter_by_array(a))
    elsif booleans.compact.empty? # [nil, nil] becomes string array
      Vector.new
    else
      raise VectorTypeError, "Argument is not a boolean: #{booleans}"
    end
  end
end

#index(element) ⇒ Object

Arrow’s support required



138
139
140
 
# File 'lib/red_amber/vector_selectable.rb', line 138

def index(element)
  to_a.index(element)
end

#is_in(*values) ⇒ Object

Parameters:

  • values (Array, Arrow::Array, Vector) 


123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/red_amber/vector_selectable.rb', line 123

def is_in(*values)
  self_data = chunked? ? data.pack : data

  array =
    case values
    in [Vector] | [Arrow::Array] | [Arrow::ChunkedArray]
      values[0].to_a
    else
      Array(values).flatten
    end

  Vector.create(self_data.is_in(array))
end

#take(*indices) {|Array<Numeric>, Vector| ... } ⇒ Vector

Select elements in the self by indices.

Parameters:

  • indices (Array<Numeric>, Vector) —

    indices.

Yields:

  • (Array<Numeric>, Vector) —

    indices.

Returns:

  • (Vector) —

    Vector by selected elements.

    TODO: support for the option ‘boundscheck: true`



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/red_amber/vector_selectable.rb', line 20

def take(*indices, &block)
  if block
    unless indices.empty?
      raise VectorArgumentError, 'Must not specify both arguments and block.'
    end

    indices = [yield]
  end

  vector =
    case indices
    in [Vector => v] if v.numeric?
      return Vector.create(take_by_vector(v))
    in []
      return Vector.new
    in [(Arrow::Array | Arrow::ChunkedArray) => aa]
      Vector.create(aa)
    else
      Vector.new(indices.flatten)
    end

  unless vector.numeric?
    raise VectorArgumentError, "argument must be a integers: #{indices}"
  end

  Vector.create(take_by_vector(vector))
end