Class: RedAmber::Vector

Inherits:
Object
  • Object
show all
Includes:
Enumerable, ArrowFunction, Helper, VectorSelectable, VectorStringFunction, VectorUpdatable
Defined in:
lib/red_amber/vector.rb,
lib/red_amber/vector_aggregation.rb,
lib/red_amber/vector_unary_element_wise.rb,
lib/red_amber/vector_binary_element_wise.rb

Overview

Representing a series of data.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from VectorStringFunction

#count_substring, #end_with, #find_substring, #match_like, #match_substring, #start_with

Methods included from VectorSelectable

#[], #drop_nil, #filter, #first, #index, #is_in, #last, #rank, #sample, #sort, #take

Methods included from VectorUpdatable

#cast, #concatenate, #fill_nil, #if_else, #list_flatten, #list_separate, #list_sizes, #merge, #primitive_invert, #replace, #shift, #split, #split_to_columns, #split_to_rows

Methods included from ArrowFunction

arrow_doc, find

Constructor Details

#initialize(*array) ⇒ Vector

Note:

default is headless Vector and ‘@key == nil’

Create a Vector.

Parameters:



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/red_amber/vector.rb', line 71

def initialize(*array)
  @data =
    case array
    in [Vector => v]
      v.data
    in [Range => r]
      Arrow::Array.new(Array(r))
    in [Arrow::Array | Arrow::ChunkedArray]
      array[0]
    in [arrow_array_like] if arrow_array_like.respond_to?(:to_arrow_array)
      arrow_array_like.to_arrow_array
    else
      Arrow::Array.new(array.flatten)
    end
end

Instance Attribute Details

#data ⇒ Arrow::Array (readonly) Also known as: to_arrow_array

Entity of Vector.

Returns:

  • (Arrow::Array) 


21
22
23
 
# File 'lib/red_amber/vector.rb', line 21

def data
  @data
end

#key ⇒ Symbol

Associated key name when self is in a DataFrame.

Default Vector is ‘head-less’ (key-less).

Returns:

  • (Symbol) 


29
30
31
 
# File 'lib/red_amber/vector.rb', line 29

def key
  @key
end

Class Method Details

.[] ⇒ Vector

Create a Vector (calling ‘.new`).

Examples:

Create an empty Vector.

Vector[]
# =>
#<RedAmber::Vector(:string, size=0):0x000000000000e2cc>
[]

Parameters:

Returns:

  • (Vector) —

    created Vector.

Since:

  • 0.5.0



44
45
46
 
# File 'lib/red_amber/vector.rb', line 44

def [](...)
  new(...)
end

.atan2(y, x) ⇒ Vector

Compute the inverse tangent of y/x.

Binary element-wise function

Returns a Vector.

The return value is in the range [-pi, pi].

Parameters:

  • y (Vector, array-like) —

    numeric array-like.

  • x (Vector, array-like) —

    numeric array-like.

Returns:

  • (Vector) —

    inverse tangent of y/x.



21
22
23
24
25
26
27
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 21

def atan2(y, x) # rubocop:disable Naming/MethodParameterName
  y = y.data if y.is_a? Vector
  x = x.data if x.is_a? Vector

  datum = Arrow::Function.find(:atan2).execute([y, x])
  Vector.create(datum.value)
end

.create(arrow_array) ⇒ Vector

Note:

This method doesn’t check argment type.

Quicker constructor of Vector.

Parameters:

  • arrow_array (Arrow::Array) —

    Arrow::Array object to have in the Vector.

Returns:

  • (Vector) —

    created Vector.



56
57
58
59
60
 
# File 'lib/red_amber/vector.rb', line 56

def create(arrow_array)
  instance = allocate
  instance.instance_variable_set(:@data, arrow_array)
  instance
end

Instance Method Details

#abs ⇒ Vector

Calculate the absolute value of self element-wise.

Results will wrap around on integer overflow.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    abs of each element of self.



57
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 57

define_unary_element_wise :abs

#abs_checked ⇒ Vector

Calculate the absolute value of self element-wise.

This function is a overflow-checking variant of #abs.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    abs of each element of self.



64
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 64

define_unary_element_wise :abs_checked

#acos ⇒ Vector

Compute the inverse cosine of self element-wise.

NaN is returned for invalid input values.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    acos of each element of self.



72
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 72

define_unary_element_wise :acos

#acos_checked ⇒ Vector

Compute the inverse cosine of self element-wise.

This function is a overflow-checking variant of #acos.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    acos of each element of self.



79
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 79

define_unary_element_wise :acos_checked

#add(other) ⇒ Vector Also known as: +

Add the arguments element-wise.

Results will wrap around on integer overflow.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, Numeric) —

    other numeric Vector or numeric scalar.

Returns:

  • (Vector) —

    adddition of self and other.



218
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 218

define_binary_element_wise :add

#add_checked ⇒ Vector

Add the arguments element-wise.

This function is a overflow-checking variant of #add.

Binary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    adddition of self and other.



226
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 226

define_binary_element_wise :add_checked

#all(skip_nulls: true, min_count: 1) ⇒ true, false Also known as: all?

Test whether all elements in self are evaluated to true.

Unary aggregation function

Returns a scalar.

Examples:

Default.

Vector.new(true, true, nil).all # => true

Skip nils.

Vector.new(true, true, nil).all(skip_nulls: false) # => false

Parameters:

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (true, false) —

    ‘all` result of self.



61
 
# File 'lib/red_amber/vector_aggregation.rb', line 61

define_unary_aggregation :all

#and_kleene(other) ⇒ Vector Also known as: &

Logical ‘and’ boolean values with Kleene logic.

This function behaves as follows with nils:

  • true and nil = nil

  • nil and true = nil

  • false and nil = false

  • nil and false = false

  • nil and nil = nil

In other words, in this context a nil value really means “unknown”, and an unknown value ‘and’ false is always false. For a different nil behavior, see function #and_org.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, array-like) —

    boolean array-like.

Returns:

  • (Vector) —

    and_kleene of self and other.



94
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 94

define_binary_element_wise :and_kleene

#and_not(other) ⇒ Vector

Logical ‘and not’ boolean values.

When a nil is encountered in either input, a nil is output. For a different nil behavior, see function #and_not_kleene.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, array-like) —

    boolean array-like.

Returns:

  • (Vector) —

    and not of self and other.



107
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 107

define_binary_element_wise :and_not

#and_not_kleene(other) ⇒ Vector

Logical ‘and not’ boolean values with Kleene logic.

This function behaves as follows with nils:

  • true and not nil = nil

  • nil and not false = nil

  • false and not nil = false

  • nil and not true = false

  • nil and not nil = nil

In other words, in this context a nil value really means “unknown”, and an unknown value ‘and not’ true is always false, as is false ‘and not’ an unknown value. For a different nil behavior, see function #and_not.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, array-like) —

    boolean array-like.

Returns:

  • (Vector) —

    and not kleene of self and other.



119
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 119

define_binary_element_wise :and_not_kleene

#and_org(other) ⇒ Vector

Logical ‘and’ boolean values.

When a nil is encountered in either input, a nil is output. For a different nil behavior, see function #and_kleene.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, array-like) —

    boolean array-like.

Returns:

  • (Vector) —

    evacuated ‘and` of self and other.



131
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 131

define_binary_element_wise_logical(:and_org, :and)

#any(skip_nulls: true, min_count: 1) ⇒ true, false Also known as: any?

Test whether any elements in self are evaluated to true.

Unary aggregation function

Returns a scalar.

Examples:

Default.

Vector.new(true, false, nil).any # => true

Parameters:

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (true, false) —

    ‘any` result of self.



73
 
# File 'lib/red_amber/vector_aggregation.rb', line 73

define_unary_aggregation :any

#approximate_median(skip_nulls: true, min_count: 1) ⇒ Float Also known as: median

Approximate median of a numeric Vector with T-Digest algorithm.

Unary aggregation function

Returns a scalar.

Parameters:

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Float) —

    median of self. A nil is returned if there is no valid data point.



84
 
# File 'lib/red_amber/vector_aggregation.rb', line 84

define_unary_aggregation :approximate_median

#array_sort_indices(order: :ascending) ⇒ Vector Also known as: sort_indexes, sort_indices, sort_index

Return the indices that would sort self.

Computes indices Vector that define a stable sort of self. By default, nils are considered greater than any other value and are therefore sorted at the end of the Vector. For floating-point types, NaNs are considered greater than any other non-nil value, but smaller than nil.

Unary element-wise function

Returns a Vector.

Parameters:

  • order (:ascending, :descending) (defaults to: :ascending) —

    ascending: Arrange values in increasing order. descending: Arrange values in decreasing order.

Returns:

  • (Vector) —

    sort indices of self.



108
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 108

define_unary_element_wise :array_sort_indices

#asin ⇒ Vector

Compute the inverse sine of self element-wise.

NaN is returned for invalid input values.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    asin of each element of self.



87
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 87

define_unary_element_wise :asin

#asin_checked ⇒ Vector

Compute the inverse sine of self element-wise.

This function is a overflow-checking variant of #asin.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    asin of each element of self.



94
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 94

define_unary_element_wise :asin_checked

#atan ⇒ Vector

Compute the inverse tangent of self element-wise.

the return value is in the range [-pi/2, pi/2]. For a full return range [-pi, pi], see atan2 .

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    atan of each element of self.



120
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 120

define_unary_element_wise :atan

#bit_wise_and(other) ⇒ Vector

Bit-wise AND of self and other by element-wise.

Nil values return nil.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, array-like) —

    integer array-like.

Returns:

  • (Vector) —

    bit wise and of self and other.



142
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 142

define_binary_element_wise :bit_wise_and

#bit_wise_not ⇒ Vector

Bit-wise negate by element-wise.

nil values reeturn nil.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    bit wise not of each element of self.



128
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 128

define_unary_element_wise :bit_wise_not

#bit_wise_or(other) ⇒ Vector

Bit-wise OR of self and other by element-wise.

Nil values return nil.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, array-like) —

    integer array-like.

Returns:

  • (Vector) —

    bit wise or of self and other.



153
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 153

define_binary_element_wise :bit_wise_or

#bit_wise_xor(other) ⇒ Vector

Bit-wise XOR of self and other by element-wise.

Nil values return nil.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, array-like) —

    integer array-like.

Returns:

  • (Vector) —

    bit wise xor of self and other.



164
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 164

define_binary_element_wise :bit_wise_xor

#boolean? ⇒ true, false

Test if self is a boolean Vector.

Returns:

  • (true, false) —

    test result.



257
258
259
 
# File 'lib/red_amber/vector.rb', line 257

def boolean?
  @data.boolean?
end

#ceil ⇒ Vector

Round up to the nearest integer.

Compute the smallest integer value not less in magnitude than each element.

Unary element-wise function

Returns a Vector.

Examples:

double = Vector.new([15.15, 2.5, 3.5, -4.5, -5.5])
double.ceil

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cd00>
[16.0, 3.0, 4.0, -4.0, -5.0]

Returns:

  • (Vector) —

    ceil of each element of self.



143
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 143

define_unary_element_wise :ceil

#chunked? ⇒ true, false

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Tests wheather self is chunked or not.

Returns:

  • (true, false) —

    returns true if #data is chunked.



383
384
385
 
# File 'lib/red_amber/vector.rb', line 383

def chunked?
  @data.is_a? Arrow::ChunkedArray
end

#coerce(other) ⇒ Object

Enable to compute with coercion mechanism.

Examples:

vector = Vector.new(1,2,3)

# =>
#<RedAmber::Vector(:uint8, size=3):0x00000000000decc4>
[1, 2, 3]

# Vector's `#*` method
vector * -1

# =>
#<RedAmber::Vector(:int16, size=3):0x00000000000e3698>
[-1, -2, -3]

# coerced calculation
-1 * vector

# =>
#<RedAmber::Vector(:int16, size=3):0x00000000000ea4ac>
[-1, -2, -3]

# `@-` operator
-vector

# =>
#<RedAmber::Vector(:uint8, size=3):0x00000000000ee7b4>
[255, 254, 253]


487
488
489
 
# File 'lib/red_amber/vector.rb', line 487

def coerce(other)
  [Vector.new(Array(other) * size), self]
end

#cos ⇒ Vector

Compute the cosine of self element-wise.

NaN is returned for invalid input values.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    cos of each element of self.



151
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 151

define_unary_element_wise :cos

#cos_checked ⇒ Vector

Compute the cosine of self element-wise.

This function is a overflow-checking variant of #cos.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    cos of each element of self.



158
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 158

define_unary_element_wise :cos_checked

#count(mode: :non_null) ⇒ Integer

Count the number of nil / non-nil values.

Unary aggregation function

Returns a scalar.

Examples:

Count only non-nil (default)

Vector.new(1.0, -2.0, Float::NAN, nil).count # => 3

Count nil only.

Vector.new(1.0, -2.0, Float::NAN, nil).count(mode: :only_null) # => 1

Count both non-nil and nil.

Vector.new(1.0, -2.0, Float::NAN, nil).count(mode: :all) # => 4

Parameters:

  • mode (:only_valid, :only_null, :all) (defaults to: :non_null) —

    control count aggregate kernel behavior.

    • only_valid: count only non-nil values.

    • only_null: count only nil.

    • all: count both.

Returns:

  • (Integer) —

    count of self.



101
 
# File 'lib/red_amber/vector_aggregation.rb', line 101

define_unary_aggregation :count

#count_distinct(mode: :only_valid) ⇒ Integer Also known as: count_uniq

Count the number of unique values.

Unary aggregation function

Returns a scalar.

Examples:

vector = Vector.new(1, 1.0, nil, nil, Float::NAN, Float::NAN)
vector

# =>
#<RedAmber::Vector(:double, size=6):0x000000000000d390>
[1.0, 1.0, nil, nil, NaN, NaN]

# Float::NANs are counted as 1.
vector.count_uniq # => 2

# nils are counted as 1.
vector.count_uniq(mode: :only_null) # => 1

vector.count_uniq(mode: :all) # => 3

Parameters:

  • mode (:only_valid, :only_null, :all) (defaults to: :only_valid) —

    control count aggregate kernel behavior.

    • only_valid: count only non-nil values.

    • only_null: count only nil.

    • all: count both.

Returns:

  • (Integer) —

    unique count of self.



125
 
# File 'lib/red_amber/vector_aggregation.rb', line 125

define_unary_aggregation :count_distinct

#cumsum ⇒ Vector

Note:

Self must be numeric.

Note:

Try to cast to Int64 if integer overflow occured.

Compute cumulative sum over the numeric Vector.

Returns:

  • (Vector) —

    cumulative sum of self.



177
178
179
180
181
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 177

def cumsum
  cumulative_sum_checked
rescue Arrow::Error::Invalid
  Vector.create(Arrow::Int64Array.new(data)).cumulative_sum_checked
end

#cumulative_sum_checked ⇒ Vector

Note:

Self must be numeric.

Note:

Return error for integer overflow.

Compute cumulative sum over the numeric Vector.

This function is a overflow-checking variant of #cumsum.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    cumulative sum of self.



168
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 168

define_unary_element_wise :cumulative_sum_checked

#dictionary? ⇒ true, false

Test if self is a dictionary Vector.

Returns:

  • (true, false) —

    test result.



302
303
304
 
# File 'lib/red_amber/vector.rb', line 302

def dictionary?
  @data.dictionary?
end

#divide(divisor) ⇒ Vector Also known as: /

Divide the arguments element-wise.

Integer division by zero returns an error. However, integer overflow wraps around, and floating-point division by zero returns an infinite.

Binary element-wise function

Returns a Vector.

Parameters:

  • divisor (Vector, Numeric) —

    numeric vector or numeric scalar as divisor.

Returns:

  • (Vector) —

    division of self by other.



238
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 238

define_binary_element_wise :divide

#divide_checked ⇒ Vector

Divide the arguments element-wise.

This function is a overflow-checking variant of #divide.

Binary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    division of self by other.



246
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 246

define_binary_element_wise :divide_checked

#each ⇒ Enumerator #each {|element| ... } ⇒ self

Iterates over Vector elements or returns a Enumerator.

Overloads:

  • #each ⇒ Enumerator

    Returns a new Enumerator if no block given.

    Returns:

    • (Enumerator) —

      Enumerator of each elements.

  • #each {|element| ... } ⇒ self

    When a block given, passes each element in self to the block.

    Yield Parameters:

    • element (Object) —

      passes element by a block parameter.

    Yield Returns:

    • (Object) —

      evaluated result value from the block.

    Returns:

    • (self) —

      returns self.



342
343
344
345
346
347
348
349
 
# File 'lib/red_amber/vector.rb', line 342

def each
  return enum_for(:each) unless block_given?

  size.times do |i|
    yield data[i]
  end
  self
end

#empty? ⇒ true, false

Test wheather self is empty.

Returns:

  • (true, false) —

    true if self is empty.



230
231
232
 
# File 'lib/red_amber/vector.rb', line 230

def empty?
  size.zero?
end

#equal(other) ⇒ Vector Also known as: ==, eq

Compare values for equality (self == other)

A nil on either side emits a nil comparison result.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector) —

    other vector or scalar.

Returns:

  • (Vector) —

    eq of self and other by a boolean Vector.



464
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 464

define_binary_element_wise :equal

#fdiv(divisor) ⇒ Vector

Returns element-wise quotient by double Vector.

Parameters:

  • divisor (Vector, numeric) —

    divisor numeric Vector or numeric scalar.

Returns:

  • (Vector) —

    quotient of dividing self by divisor.



330
331
332
333
334
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 330

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

#fdiv_checked(divisor) ⇒ Object

Returns element-wise quotient by double Vector.

This function is a overflow-checking variant of #quotient.



341
342
343
344
345
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 341

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

#fill_null_backward ⇒ Vector Also known as: fill_nil_backward

Note:

Use ‘fill_nil(value)` to replace nil by a value.

Carry non-nil values backward to fill nil slots.

Propagate next valid value backward to previous nil values. Or nothing if all next values are nil.

Unary element-wise function

Returns a Vector.

Examples:

integer = Vector.new([0, 1, nil, 3, nil])
integer.fill_nil_backward

# =>
#<RedAmber::Vector(:uint8, size=5):0x000000000000f974>
[0, 1, 3, 3, nil]

Returns:

  • (Vector) —

    a Vector which filled nil backward.

See Also:



199
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 199

define_unary_element_wise :fill_null_backward

#fill_null_forward ⇒ Vector Also known as: fill_nil_forward

Note:

Use ‘fill_nil(value)` to replace nil by a value.

Carry non-nil values forward to fill nil slots.

Propagate last valid value backward to next nil values. Or nothing if all previous values are nil.

Unary element-wise function

Returns a Vector.

Examples:

integer = Vector.new([0, 1, nil, 3, nil])
integer.fill_nil_forward

# =>
#<RedAmber::Vector(:uint8, size=5):0x000000000000f960>
[0, 1, 1, 3, 3]

Returns:

  • (Vector) —

    a Vector which filled nil forward.

See Also:



218
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 218

define_unary_element_wise :fill_null_forward

#float? ⇒ true, false

Test if self is a float Vector.

Returns:

  • (true, false) —

    test result.



275
276
277
 
# File 'lib/red_amber/vector.rb', line 275

def float?
  @data.float?
end

#floor ⇒ Vector

Round down to the nearest integer.

Compute the largest integer value not greater in magnitude than each element.

Unary element-wise function

Returns a Vector.

Examples:

double = Vector.new([15.15, 2.5, 3.5, -4.5, -5.5])
double.floor

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cd14>
[15.0, 2.0, 3.0, -5.0, -6.0]

Returns:

  • (Vector) —

    floor of each element of self.



234
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 234

define_unary_element_wise :floor

#greater(other) ⇒ Vector Also known as: >, gt

Compare values for ordered inequality (self > other).

A nil on either side emits a nil comparison result.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector) —

    other vector or scalar.

Returns:

  • (Vector) —

    gt of self and other by a boolean Vector.



477
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 477

define_binary_element_wise :greater

#greater_equal(other) ⇒ Vector Also known as: >=, ge

Compare values for ordered inequality (self >= other).

A nil on either side emits a nil comparison result.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector) —

    other vector or scalar.

Returns:

  • (Vector) —

    ge of self and other by a boolean Vector.



490
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 490

define_binary_element_wise :greater_equal

#has_nil? ⇒ true, false

Return true if self has any nil.

Returns:

  • (true, false) —

    true or false.



453
454
455
 
# File 'lib/red_amber/vector.rb', line 453

def has_nil?
  is_nil.any
end

#indices ⇒ Array Also known as: indexes, indeces

Indeces from 0 to size-1 by Array.

Returns:

  • (Array) —

    indices.



206
207
208
 
# File 'lib/red_amber/vector.rb', line 206

def indices
  (0...size).to_a
end

#inspect(limit: 80) ⇒ String

String representation of self.

According to ‘ENV [“RED_AMBER_OUTPUT_MODE”].upcase`,

  • If it is ‘MINIMUM’, returns class and size.

  • If it is otherwise, returns class, size and preview. Default value of the ENV is ‘Table’.

Examples:

Default (ENV [‘RED_AMBER_OUTPUT_MODE’] == ‘Table’)

puts vector.inspect

# =>
#<RedAmber::Vector(:uint8, size=3):0x00000000000037f0>
[1, 2, 3]

In case of ENV [‘RED_AMBER_OUTPUT_MODE’] == ‘Minimum’

puts vector.inspect

# =>
RedAmber::Vector(:uint8, size=3)

Parameters:

  • limit (Integer) (defaults to: 80) —

    max width of the result.

Returns:

  • (String) —

    show information of self as a String.



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/red_amber/vector.rb', line 166

def inspect(limit: 80)
  if ENV.fetch('RED_AMBER_OUTPUT_MODE', 'Table').casecmp('MINIMUM').zero?
    # Better performance than `.upcase == 'MINIMUM'`
    "#{self.class}(:#{type}, size=#{size})"
  else
    sio = StringIO.new << '['
    each.with_index do |e, i|
      next_str = "#{sio.size > 1 ? ', ' : ''}#{e.inspect}"
      if (sio.size + next_str.size) < limit
        sio << next_str
      else
        sio << ', ... ' if i < size
        break
      end
    end
    sio << ']'

    chunked = chunked? ? ', chunked' : ''
    format "#<#{self.class}(:#{type}, size=#{size}#{chunked}):0x%016x>\n%s\n",
           object_id, sio.string
  end
end

#integer? ⇒ true, false

Test if self is a integer Vector.

Returns:

  • (true, false) —

    test result.



284
285
286
 
# File 'lib/red_amber/vector.rb', line 284

def integer?
  @data.integer?
end

#invert ⇒ Vector Also known as: !, not

Invert boolean values

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    not of each element of self.



513
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 513

define_unary_element_wise :invert

#is_finite ⇒ Vector

Return true if value is finite.

For each input value, emit true if the value is finite. (i.e. neither NaN, inf, nor -inf).

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    boolean Vector wheather each element is finite.



243
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 243

define_unary_element_wise :is_finite

#is_inf ⇒ Vector

Return true if value is infinity.

For each input value, emit true if the value is infinite (inf or -inf).

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    boolean Vector wheather each element is inf.



251
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 251

define_unary_element_wise :is_inf

#is_na ⇒ Vector

return true if value is nil or NaN.

For each input value, emit true if the value is nil or NaN.

Returns:

  • (Vector) —

    boolean Vector wheather each element is na.



259
260
261
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 259

def is_na # rubocop:disable Naming/PredicateName
  numeric? ? (is_nil | is_nan) : is_nil
end

#is_nan ⇒ Vector

Return true if NaN.

For each input value, emit true if the value is NaN.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    boolean Vector wheather each element is nan.



269
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 269

define_unary_element_wise :is_nan

#is_null ⇒ Vector Also known as: is_nil

Note:

Arrow::NullOptions is not supported yet.

Return true if nil.

For each input value, emit true if the value is nil.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    boolean Vector wheather each element is null.



278
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 278

define_unary_element_wise :is_null

#is_valid ⇒ Vector

Return true if non-nil.

For each input value, emit true if the value is valid (i.e. non-nil).

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    boolean Vector wheather each element is valid.



287
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 287

define_unary_element_wise :is_valid

#less(other) ⇒ Vector Also known as: <, lt

Compare values for ordered inequality (self < other).

A nil on either side emits a nil comparison result.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector) —

    other vector or scalar.

Returns:

  • (Vector) —

    lt of self and other by a boolean Vector.



503
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 503

define_binary_element_wise :less

#less_equal(other) ⇒ Vector Also known as: <=, le

Compare values for ordered inequality (self <= other).

A nil on either side emits a nil comparison result.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector) —

    other vector or scalar.

Returns:

  • (Vector) —

    le of self and other by a boolean Vector.



516
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 516

define_binary_element_wise :less_equal

#list? ⇒ true, false

Test if self is a list Vector.

Returns:

  • (true, false) —

    test result.



320
321
322
 
# File 'lib/red_amber/vector.rb', line 320

def list?
  @data.list?
end

#ln ⇒ Vector

Compute natural logarithm.

Non-positive values return -inf or NaN. Nil values return nil.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    natural logarithm of each element of self.



295
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 295

define_unary_element_wise :ln

#ln_checked ⇒ Vector

Compute natural logarithm.

This function is a overflow-checking variant of #ln.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    natural logarithm of each element of self.



302
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 302

define_unary_element_wise :ln_checked

#log10 ⇒ Vector

Compute base 10 logarithm.

Non-positive values return -inf or NaN. Nil values return nil.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    base 10 logarithm of each element of self.



310
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 310

define_unary_element_wise :log10

#log10_checked ⇒ Vector

Compute base 10 logarithm.

This function is a overflow-checking variant of #log10.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    base 10 logarithm of each element of self.



317
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 317

define_unary_element_wise :log10_checked

#log1p ⇒ Vector

Compute natural log of (1+x).

Non-positive values return -inf or NaN. Nil values return nil. This function may be more precise than log(1 + x) for x close to zero.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    natural log of (each element + 1) of self.



326
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 326

define_unary_element_wise :log1p

#log1p_checked ⇒ Vector

Compute natural log of (1+x).

This function is a overflow-checking variant of #log1p.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    natural log of (each element + 1) of self.



333
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 333

define_unary_element_wise :log1p_checked

#log2 ⇒ Vector

Compute base 2 logarithm.

Non-positive values return -inf or NaN. Nil values return nil.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    base 2 logarithm of each element of self.



341
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 341

define_unary_element_wise :log2

#log2_checked ⇒ Vector

Compute base 2 logarithm.

This function is a overflow-checking variant of #log2.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    base 2 logarithm of each element of self.



348
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 348

define_unary_element_wise :log2_checked

#logb(b) ⇒ Vector

Compute base ‘b` logarithm of self.

Non positive values return -inf or NaN. Nil values return nil.

Binary element-wise function

Returns a Vector.

Parameters:

  • b (Integer) —

    base.

Returns:

  • (Vector) —

    logb of self and other.



175
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 175

define_binary_element_wise :logb

#logb_checked ⇒ Vector

Compute base ‘b` logarithm of self.

This function is a overflow-checking variant of #logb.

Binary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    logb of self and other.



182
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 182

define_binary_element_wise :logb_checked

#map ⇒ Enumerator #map {|element| ... } ⇒ self Also known as: collect

Returns a Vector from collected objects from the block.

Overloads:

  • #map ⇒ Enumerator

    Returns a new Enumerator if no block given.

    Returns:

    • (Enumerator) —

      a new Enumerator.

  • #map {|element| ... } ⇒ self

    When a block given, calls the block with successive elements. Returns a Vector of the objects returned by the block.

    Yield Parameters:

    • element (Object) —

      passes element by a block parameter.

    Yield Returns:

    • (Object) —

      evaluated result value from the block.

    Returns:

    • (self) —

      returns the collected values from the block as a Vector.



370
371
372
373
374
 
# File 'lib/red_amber/vector.rb', line 370

def map(&block)
  return enum_for(:map) unless block

  Vector.new(to_a.map(&block))
end

#max(skip_nulls: true, min_count: 1) ⇒ Numeric

Compute maximum value of self.

Unary aggregation function

Returns a scalar.

Parameters:

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Numeric) —

    maximum value of self.



135
 
# File 'lib/red_amber/vector_aggregation.rb', line 135

define_unary_aggregation :max

#mean(skip_nulls: true, min_count: 1) ⇒ Numeric

Compute mean value of self.

Unary aggregation function

Returns a scalar.

Parameters:

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Numeric) —

    mean of self.



144
 
# File 'lib/red_amber/vector_aggregation.rb', line 144

define_unary_aggregation :mean

#min(skip_nulls: true, min_count: 1) ⇒ Numeric

Compute minimum value of self.

Unary aggregation function

Returns a scalar.

Parameters:

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Numeric) —

    minimum of self.



153
 
# File 'lib/red_amber/vector_aggregation.rb', line 153

define_unary_aggregation :min

#min_max(skip_nulls: true, min_count: 1) ⇒ Array<min, max>

Compute the min and max value of self.

Unary aggregation function

Returns a scalar.

Parameters:

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Array<min, max>) —

    min and max of self in an Array.



162
 
# File 'lib/red_amber/vector_aggregation.rb', line 162

define_unary_aggregation :min_max

#mode ⇒ Hash{'mode'=>mode, 'count'=>count}

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

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.

Compute the 1 most common values and their respective

occurence counts.

Returns:

Since:

  • 0.5.0



175
176
177
178
 
# File 'lib/red_amber/vector_aggregation.rb', line 175

def mode
  datum = find(:mode).execute([data])
  datum.value.to_a.first
end

#modulo(divisor) ⇒ Vector Also known as: %

Note:

Same behavior as Ruby.

Returns element-wise modulo.

This is equivalent to ‘self-divisor*(self/divisor).floor`.

Parameters:

  • divisor (Vector, numeric) —

    divisor numeric Vector or numeric scalar.

Returns:

  • (Vector) —

    modulo of dividing self by divisor.



257
258
259
260
261
262
263
264
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 257

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, divisor])
  datum = find(:subtract).execute([data, m])
  Vector.create(datum.value)
end

#modulo_checked(divisor) ⇒ Vector

Returns element-wise modulo.

This function is a overflow-checking variant of #modulo.

Returns:

  • (Vector) —

    modulo of dividing self by divisor.



272
273
274
275
276
277
278
279
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 272

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, divisor])
  datum = find(:subtract_checked).execute([data, m])
  Vector.create(datum.value)
end

#multiply(other) ⇒ Vector Also known as: mul, *

Multiply the arguments element-wise.

Results will wrap around on integer overflow.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, Numeric) —

    other numeric vector or numeric scalar.

Returns:

  • (Vector) —

    multiplication of self and other.



290
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 290

define_binary_element_wise :multiply

#multiply_checked ⇒ Vector

Multiply the arguments element-wise.

This function is a overflow-checking variant of #multiply.

Binary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    multiplication of self and other.



299
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 299

define_binary_element_wise :multiply_checked

#n_chunks ⇒ Integer

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the number of chunks.

Returns:

  • (Integer) —

    the number of chunks. If self is not chunked, returns zero.



393
394
395
 
# File 'lib/red_amber/vector.rb', line 393

def n_chunks
  chunked? ? @data.n_chunks : 0
end

#n_nans ⇒ Integer

Count NaNs in self if self is a numeric Vector

Returns:

  • (Integer) —

    the number of Float::NANs. If self is not a numeric Vector, returns 0.



444
445
446
 
# File 'lib/red_amber/vector.rb', line 444

def n_nans
  numeric? ? is_nan.to_a.count(true) : 0
end

#n_nulls ⇒ Integer Also known as: n_nils

Count nils in self.

Returns:

  • (Integer) —

    the number of nils.



433
434
435
 
# File 'lib/red_amber/vector.rb', line 433

def n_nulls
  @data.n_nulls
end

#negate ⇒ Vector Also known as: -@

Negate the argument element-wise

Results will wrap around on integer overflow.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    negate of each element of self.



523
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 523

define_unary_element_wise :negate

#negate_checked ⇒ Vector

Negate the argument element-wise

This function is a overflow-checking variant of #negate.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    negate of each element of self.



531
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 531

define_unary_element_wise :negate_checked

#not_equal(other) ⇒ Vector Also known as: !=, ne

Compare values for inequality (self != other).

A nil on either side emits a nil comparison result.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector) —

    other vector or scalar.

Returns:

  • (Vector) —

    ne of self and other by a boolean Vector.



529
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 529

define_binary_element_wise :not_equal

#numeric? ⇒ true, false

Test if self is a numeric Vector.

Returns:

  • (true, false) —

    test result.



266
267
268
 
# File 'lib/red_amber/vector.rb', line 266

def numeric?
  @data.numeric?
end

#one ⇒ Object?

Get a non-nil element in self.

Returns:

  • (Object, nil) —

    first non-nil value detected. If all elements are nil, return nil.

Since:

  • 0.5.0



266
267
268
 
# File 'lib/red_amber/vector_aggregation.rb', line 266

def one
  each.find { !_1.nil? }
end

#or_kleene(other) ⇒ Vector Also known as: |

Logical ‘or’ boolean values with Kleene logic.

This function behaves as follows with nils:

  • true or nil = true

  • nil or true = true

  • false or nil = nil

  • nil or false = nil

  • nil or nil = nil

In other words, in this context a nil value really means “unknown”, and an unknown value ‘or’ true is always true. For a different nil behavior, see function #or_org.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, array-like) —

    boolean array-like.

Returns:

  • (Vector) —

    or_kleene of self and other.



194
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 194

define_binary_element_wise :or_kleene

#or_org(other) ⇒ Vector

Logical ‘or’ boolean values.

When a nil is encountered in either input, a nil is output. For a different nil behavior, see function #or_kleene.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, array-like) —

    boolean array-like.

Returns:

  • (Vector) —

    evacuated ‘or` of self and other.



207
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 207

define_binary_element_wise_logical(:or_org, :or)

#power(exponent) ⇒ Vector Also known as: pow, **

Raise arguments to power element-wise.

Integer to negative integer power returns an error. However, integer overflow wraps around. If either self or exponent is nil the result will be nil.

Binary element-wise function

Returns a Vector.

Parameters:

  • exponent (Vector, Numeric) —

    numeric vector or numeric scalar as exponent.

Returns:

  • (Vector) —

    power operation of self and other.



312
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 312

define_binary_element_wise :power

#power_checked ⇒ Vector

Raise arguments to power element-wise.

This function is a overflow-checking variant of #power.

Binary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    power operation of self and other.



321
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 321

define_binary_element_wise :power_checked

#product(skip_nulls: true, min_count: 1) ⇒ Numeric

Note:

Self must be a numeric Vector.

Compute product value of self.

Unary aggregation function

Returns a scalar.

Parameters:

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Numeric) —

    product of self.



188
 
# File 'lib/red_amber/vector_aggregation.rb', line 188

define_unary_aggregation :product

#propagate(function) ⇒ Vector #propagate {|self| ... } ⇒ Vector Also known as: expand

Spread the return value of an aggregate function as if

it is a element-wise function.

Overloads:

  • #propagate(function) ⇒ Vector

    Returns a Vector of same size as self spreading the value from function.

    Examples:

    propagate by an aggragation function name

    vec = Vector.new(1, 2, 3, 4)
vec.propagate(:mean)
# =>
#<RedAmber::Vector(:double, size=4):0x000000000001985c>
[2.5, 2.5, 2.5, 2.5]

    Parameters:

    • function (Symbol) —

      a name of aggregation function for self. Return value of the function must be a scalar.

    Returns:

    • (Vector) —

      Returns a Vector that is the same size as self and such that all elements are the same as the result of aggregation ‘function`.

  • #propagate {|self| ... } ⇒ Vector

    Returns a Vector of same size as self spreading the value from block.

    Examples:

    propagate by a block

    vec.propagate { |v| v.mean.round }
# =>
#<RedAmber::Vector(:uint8, size=4):0x000000000000cb98>
[3, 3, 3, 3]

    Yield Parameters:

    • self (Vector) —

      gives self to the block.

    Yield Returns:

    • (scalar) —

      a scalar value.

    Returns:

    • (Vector) —

      returns a Vector that is the same size as self and such that all elements are the same as the yielded value from the block.

Raises:

Since:

  • 0.4.0



526
527
528
529
530
531
532
533
534
535
536
537
538
 
# File 'lib/red_amber/vector.rb', line 526

def propagate(function = nil, &block)
  value =
    if block
      raise VectorArgumentError, "can't specify both function and block" if function

      yield self
    else
      send(function&.to_sym)
    end
  raise VectorArgumentError, 'not an aggregation function' if value.is_a?(Vector)

  Vector.new([value] * size)
end

#quantile(prob = 0.5, interpolation: :linear, skip_nulls: true, min_count: 0) ⇒ Float

Returns a quantile value.

  • 0.5 quantile (median) is returned by default.

  • Or return quantile for specified probability (prob).

  • If quantile lies between two data points, interpolated value is returned based on selected interpolation method.

  • Nils and NaNs are ignored.

  • Nil is returned if there are no valid data point.

Examples:

penguins[:bill_depth_mm].quantile

# =>
17.3 # defaultis prob = 0.5

Parameters:

  • prob (Float) (defaults to: 0.5) —

    probability.

  • interpolation (Symbol) (defaults to: :linear) —

    specifies interpolation method to use, when the quantile lies between the data i and j.

    • Default value is :linear, which returns i + (j - i) * fraction.

    • lower: returns i.

    • higher: returns j.

    • nearest: returns i or j, whichever is closer.

    • midpoint: returns (i + j) / 2.

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 0) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Float) —

    quantile of self.



290
291
292
293
294
295
296
297
298
299
300
301
302
 
# File 'lib/red_amber/vector_aggregation.rb', line 290

def quantile(prob = 0.5, interpolation: :linear, skip_nulls: true, min_count: 0)
  unless (0..1).cover? prob
    raise VectorArgumentError,
          "Invalid: probability #{prob} must be between 0 and 1"
  end

  datum = find(:quantile).execute([data],
                                  q: prob,
                                  interpolation: interpolation,
                                  skip_nulls: skip_nulls,
                                  min_count: min_count)
  datum.value.to_a.first
end

#quantiles(probs = [0.0, 0.25, 0.5, 0.75, 1.0], interpolation: :linear, skip_nulls: true, min_count: 0) ⇒ DataFrame

Return quantiles in a DataFrame

Examples:

penguins[:bill_depth_mm].quantiles([0.05, 0.95])

# =>
#<RedAmber::DataFrame : 2 x 2 Vectors, 0x000000000000fb2c>
     probs quantiles
  <double>  <double>
0     0.05      13.9
1     0.95      20.0

Parameters:

  • probs (Array) (defaults to: [0.0, 0.25, 0.5, 0.75, 1.0]) —

    Array of probabilities. Default probabilities are 0.0, 0.25, 0.5 0.75, 1.0 .

  • interpolation (Symbol) (defaults to: :linear) —

    specifies interpolation method to use, when the quantile lies between the data i and j.

    • Default value is :linear, which returns i + (j - i) * fraction.

    • lower: returns i.

    • higher: returns j.

    • nearest: returns i or j, whichever is closer.

    • midpoint: returns (i + j) / 2.

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 0) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:



322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
 
# File 'lib/red_amber/vector_aggregation.rb', line 322

def quantiles(probs = [0.0, 0.25, 0.5, 0.75, 1.0],
              interpolation: :linear, skip_nulls: true, min_count: 0)
  if probs.empty? || !probs.all? { |q| (0..1).cover?(q) }
    raise VectorArgumentError, "Invarid probavilities #{probs}"
  end

  DataFrame.new(
    probs: probs,
    quantiles: probs.map do |q|
      quantile(q,
               interpolation: interpolation, skip_nulls: skip_nulls,
               min_count: min_count)
    end
  )
end

#remainder(divisor) ⇒ Vector

Note:

Same behavior as Ruby’s remainder.

Returns element-wise remainder.

This is equivalent to ‘self-divisor*(self/divisor).trunc`.

Parameters:

  • divisor (Vector, numeric) —

    divisor numeric Vector or numeric scalar.

Returns:

  • (Vector) —

    modulo of dividing self by divisor.



356
357
358
359
360
361
362
363
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 356

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

#remainder_checked(divisor) ⇒ Vector

Returns element-wise modulo.

This function is a overflow-checking variant of #modulo.

Returns:

  • (Vector) —

    modulo of dividing self by divisor.



370
371
372
373
374
375
376
377
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 370

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

#resolve(other) ⇒ Vector

Return other as a Vector which is same data type as self.

Examples:

Integer to String

Vector.new('A').resolve([1, 2])

# =>
#<RedAmber::Vector(:string, size=2):0x00000000000037b4>
["1", "2"]

String to Ineger

Vector.new(1).resolve(['A'])

# =>
#<RedAmber::Vector(:uint8, size=1):0x00000000000037dc>
[65]

Upcast to uint16

vector = Vector.new(256)

# =>
#<RedAmber::Vector(:uint16, size=1):0x000000000000c1fc>
[256]

vector.resolve([1, 2])

# =>
# Not a uint8 Vector
#<RedAmber::Vector(:uint16, size=2):0x000000000000c328>
[1, 2]

Parameters:

  • other (Vector, Array, Arrow::Array, Arrow::ChunkedArray) —

    a source array-like which will be converted.

Returns:

  • (Vector) —

    resolved Vector.

Since:

  • 0.4.0



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

def resolve(other)
  case other
  when Vector
    Vector.create(data.resolve(other.data))
  when Array, Arrow::Array, Arrow::ChunkedArray
    Vector.create(data.resolve(other))
  else
    raise VectorArgumentError, "invalid argument: #{other}"
  end
end

#round(n_digits: 0, round_mode: :half_to_even) ⇒ Vector

Round to a given precision.

Options are used to control the number of digits and rounding mode. Default behavior is to round to the nearest integer and use half-to-even rule to break ties.

Unary element-wise function

Returns a Vector.

Examples:

double = Vector.new([15.15, 2.5, 3.5, -4.5, -5.5])
double.round
# or double.round(n_digits: 0, mode: :half_to_even)

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cd28>
[15.0, 2.0, 4.0, -4.0, -6.0]

double.round(mode: :towards_infinity)

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cd3c>
[16.0, 3.0, 4.0, -5.0, -6.0]

double.round(mode: :half_up)

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cd50>
[15.0, 3.0, 4.0, -4.0, -5.0]

double.round(mode: :half_towards_zero)

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cd64>
[15.0, 2.0, 3.0, -4.0, -5.0]

double.round(mode: :half_towards_infinity)

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cd78>
[15.0, 3.0, 4.0, -5.0, -6.0]

double.round(mode: :half_to_odd)

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cd8c>
[15.0, 3.0, 3.0, -5.0, -5.0]

double.round(n_digits: 1)

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cda0>
[15.2, 2.5, 3.5, -4.5, -5.5]

double.round(n_digits: -1)

# =>
#<RedAmber::Vector(:double, size=5):0x000000000000cdb4>
[20.0, 0.0, 0.0, -0.0, -10.0]

Parameters:

  • n_digits (Integer) (defaults to: 0) —

    Rounding precision (number of digits to round to).

  • round_mode (:down, :up, :towards_zero, :towards_infinity, :half_down, :half_up, :half_towards_zero, :half_towards_infinity, :half_to_even, :half_to_odd) (defaults to: :half_to_even) —

    Rounding and tie-breaking mode.

    • down: Round to nearest integer less than or equal in magnitude (aka “floor”).

    • up: Round to nearest integer greater than or equal in magnitude (aka “ceil”).

    • towards_zero: Get the integral part without fractional digits (aka “trunc”).

    • towards_infinity: Round negative values with :down rule and positive values with :up rule (aka “away from zero”).

    • half_down: Round ties with :down rule (also called “round half towards negative infinity”).

    • half_up: Round ties with :up rule (also called “round half towards positive infinity”).

    • half_towards_zero: Round ties with :towards_zero rule (also called “round half away from infinity”).

    • half_towards_infinity: Round ties with :towards_infinity rule (also called “round half away from zero”).

    • half_to_even: Round ties to nearest even integer.

    • half_to_odd: Round ties to nearest odd integer.

Returns:

  • (Vector) —

    round of each element of self.



412
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 412

define_unary_element_wise :round

#round_to_multiple(multiple: 1.0, round_mode: :half_to_even) ⇒ Vector

Round to a given multiple.

Options are used to control the rounding multiple and rounding mode. Default behavior is to round to the nearest integer and use half-to-even rule to break ties.

Parameters:

  • multiple (Float, Integer) (defaults to: 1.0) —

    Rounding scale (multiple to round to). Should be a positive numeric scalar of a type compatible with the argument to be rounded. The cast kernel is used to convert the rounding multiple to match the result type.

  • round_mode (:down, :up, :towards_zero, :towards_infinity, :half_down, :half_up, :half_towards_zero, :half_towards_infinity, :half_to_even, :half_to_odd) (defaults to: :half_to_even) —

    Rounding and tie-breaking mode.

    • down: Round to nearest integer less than or equal in magnitude (aka “floor”).

    • up: Round to nearest integer greater than or equal in magnitude (aka “ceil”).

    • towards_zero: Get the integral part without fractional digits (aka “trunc”).

    • towards_infinity: Round negative values with :down rule and positive values with :up rule (aka “away from zero”).

    • half_down: Round ties with :down rule (also called “round half towards negative infinity”).

    • half_up: Round ties with :up rule (also called “round half towards positive infinity”).

    • half_towards_zero: Round ties with :towards_zero rule (also called “round half away from infinity”).

    • half_towards_infinity: Round ties with :towards_infinity rule (also called “round half away from zero”).

    • half_to_even: Round ties to nearest even integer.

    • half_to_odd: Round ties to nearest odd integer.

Returns:

  • (Vector) —

    round to multiple of each element of self.



429
430
431
432
433
434
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 429

def round_to_multiple(multiple: 1.0, round_mode: :half_to_even)
  datum = exec_func_unary(:round_to_multiple,
                          multiple: Arrow::DoubleScalar.new(multiple),
                          round_mode: round_mode)
  Vector.create(datum.value)
end

#sd(ddof: 1, skip_nulls: true, min_count: 1) ⇒ Float Also known as: std

Note:

Self must be a numeric Vector.

Calculate unbiased standard deviation of self.

Parameters:

  • ddof (0, 1) (defaults to: 1) —

    Control Delta Degrees of Freedom (ddof) of Variance and Stddev kernel. The divisor used in calculations is N - ddof, where N is the number of elements. By default, ddof is zero, and population variance or stddev is returned.

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Float) —

    standard deviation of self. Unviased (ddof=1)by default.



208
209
210
 
# File 'lib/red_amber/vector_aggregation.rb', line 208

def sd
  stddev(ddof: 1)
end

#shift_left(amount) ⇒ Vector Also known as: <<

Left shift of self by other.

The shift operates as if on the two’s complement representation of the number. In other words, this is equivalent to multiplying self by 2 to the power ‘amount’, even if overflow occurs. self is returned if ‘amount’ (the amount to shift by) is negative or greater than or equal to the precision of self.

Binary element-wise function

Returns a Vector.

Parameters:

  • amount (integer) —

    the amount to shift by.

Returns:

  • (Vector) —

    shift_left of self by amount.



412
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 412

define_binary_element_wise :shift_left

#shift_left_checked ⇒ Vector

Left shift of self by other.

This function is a overflow-checking variant of #shift_left.

Binary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    shift_left of self by amount.



420
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 420

define_binary_element_wise :shift_left_checked

#shift_right(amount) ⇒ Vector Also known as: >>

Right shift of self by other.

This is equivalent to dividing ‘x` by 2 to the power `y`. Self is returned if ’amount’ (the amount to shift by) is: negative or greater than or equal to the precision of self.

Binary element-wise function

Returns a Vector.

Parameters:

  • amount (integer) —

    the amount to shift by.

Returns:

  • (Vector) —

    shift_right of self by amount.



433
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 433

define_binary_element_wise :shift_right

#shift_right_checked ⇒ Vector

Right shift of self by other.

This function is a overflow-checking variant of #shift_right.

Binary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    shift_right of self by amount.



441
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 441

define_binary_element_wise :shift_right_checked

#sign ⇒ Vector

Get the signedness of the arguments element-wise.

Output is any of (-1,1) for nonzero inputs and 0 for zero input. NaN values return NaN. Integral values return signedness as Int8 and floating-point values return it with the same type as the input values.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    sign of each element of self.



444
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 444

define_unary_element_wise :sign

#sin ⇒ Vector

Compute the sine of self element-wise.

NaN is returned for invalid input values.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    sine of each element of self.



452
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 452

define_unary_element_wise :sin

#sin_checked ⇒ Vector

Compute the sine of self element-wise.

This function is a overflow-checking variant of #sin.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    sine of each element of self.



459
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 459

define_unary_element_wise :sin_checked

#size ⇒ Integer Also known as: length, n_rows, nrow

Vector size.

Returns:

  • (Integer) —

    size of self.



217
218
219
220
 
# File 'lib/red_amber/vector.rb', line 217

def size
  # only defined :length in Arrow?
  @data.length
end

#sqrt ⇒ Vector

Compute square root of self.

NaN is returned for invalid input values.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    sqrt of each element of self.



467
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 467

define_unary_element_wise :sqrt

#sqrt_checked ⇒ Vector

Compute square root of self.

This function is a overflow-checking variant of #sqrt.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    sqrt of each element of self.



474
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 474

define_unary_element_wise :sqrt_checked

#stddev(ddof: 0, skip_nulls: true, min_count: 1) ⇒ Float

Note:

Self must be a numeric Vector.

Calculate standard deviation of self.

Unary aggregation function

Returns a scalar.

Parameters:

  • ddof (0, 1) (defaults to: 0) —

    Control Delta Degrees of Freedom (ddof) of Variance and Stddev kernel. The divisor used in calculations is N - ddof, where N is the number of elements. By default, ddof is zero, and population variance or stddev is returned.

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Float) —

    standard deviation of self. Biased (ddof=0) by default.



198
 
# File 'lib/red_amber/vector_aggregation.rb', line 198

define_unary_aggregation :stddev

#string? ⇒ true, false

Test if self is a string Vector.

Returns:

  • (true, false) —

    test result.



293
294
295
 
# File 'lib/red_amber/vector.rb', line 293

def string?
  @data.string?
end

#subtract(other) ⇒ Vector Also known as: sub, -

Subtract the arguments element-wise.

Results will wrap around on integer overflow.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector, Numeric) —

    other numeric vector or numeric scalar.

Returns:

  • (Vector) —

    subtraction of self and other.



388
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 388

define_binary_element_wise :subtract

#subtract_checked ⇒ Vector

Subtract the arguments element-wise.

This function is a overflow-checking variant of #subtract.

Binary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    subtraction of self and other.



397
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 397

define_binary_element_wise :subtract_checked

#sum(skip_nulls: true, min_count: 1) ⇒ Numeric

Note:

Self must be a numeric Vector.

Compute sum of self.

Unary aggregation function

Returns a scalar.

Parameters:

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Numeric) —

    sum of self.



221
 
# File 'lib/red_amber/vector_aggregation.rb', line 221

define_unary_aggregation :sum

#tally ⇒ Hash

Returns a hash containing the counts of equal elements.

  • Each key is an element of self.

  • Each value is the number of elements equal to the key.

Returns:

  • (Hash) —

    result in a Hash.



406
407
408
409
410
411
412
413
414
415
416
417
418
419
 
# File 'lib/red_amber/vector.rb', line 406

def tally
  hash = values.tally
  if (type_class < Arrow::FloatingPointDataType) && is_nan.any
    a = 0
    hash.each do |key, value|
      if key.is_a?(Float) && key.nan?
        hash.delete(key)
        a += value
      end
    end
    hash[Float::NAN] = a
  end
  hash
end

#tan ⇒ Vector

Compute the tangent of self element-wise.

NaN is returned for invalid input values.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    tangent of each element of self.



482
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 482

define_unary_element_wise :tan

#tan_checked ⇒ Vector

Compute the tangent of self element-wise.

This function is a overflow-checking variant of #tan.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    tangent of each element of self.



489
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 489

define_unary_element_wise :tan_checked

#temporal? ⇒ true, false

Test if self is a temporal Vector.

Returns:

  • (true, false) —

    test result.



311
312
313
 
# File 'lib/red_amber/vector.rb', line 311

def temporal?
  @data.temporal?
end

#to_ary ⇒ Array Also known as: to_a, values, entries

Convert to an Array.

Returns:

  • (Array) —

    array representation.



194
195
196
 
# File 'lib/red_amber/vector.rb', line 194

def to_ary
  @data.values
end

#to_s ⇒ String

String representation of self like an Array.

Returns:

  • (String) —

    return self as same as Array’s inspect.



139
140
141
 
# File 'lib/red_amber/vector.rb', line 139

def to_s
  @data.to_a.inspect
end

#trunc ⇒ Vector

Compute the integral part

Compute the nearest integer not greater in magnitude than each element.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    trunc of each element of self.



497
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 497

define_unary_element_wise :trunc

#type ⇒ Symbol

Type nickname of self.

Returns:

  • (Symbol) —

    type nickname of values.



239
240
241
 
# File 'lib/red_amber/vector.rb', line 239

def type
  list? ? :list : @data.value_type.nick.to_sym
end

#type_class ⇒ type_Class

Type Class of self.

Returns:

  • (type_Class) —

    type class.



248
249
250
 
# File 'lib/red_amber/vector.rb', line 248

def type_class
  @data.type_class
end

#unbiased_variance(ddof: 1, skip_nulls: true, min_count: 1) ⇒ Float Also known as: var

Note:

self must be a numeric Vector.

Calculate unbiased variance of self.

Parameters:

  • ddof (0, 1) (defaults to: 1) —

    Control Delta Degrees of Freedom (ddof) of Variance and Stddev kernel. The divisor used in calculations is N - ddof, where N is the number of elements. By default, ddof is zero, and population variance or stddev is returned.

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Float) —

    variance of self. Unviased (ddof=1) by default.



245
246
247
 
# File 'lib/red_amber/vector_aggregation.rb', line 245

def unbiased_variance
  variance(ddof: 1)
end

#unique ⇒ Vector Also known as: uniq

Compute unique elements

Return an array with distinct values. Nils in the input are ignored.

Unary element-wise function

Returns a Vector.

Returns:

  • (Vector) —

    uniq element of self.



505
 
# File 'lib/red_amber/vector_unary_element_wise.rb', line 505

define_unary_element_wise :unique

#value_counts ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Arrow imprementation of #tally



423
424
425
426
 
# File 'lib/red_amber/vector.rb', line 423

def value_counts
  values, counts = Arrow::Function.find(:value_counts).execute([data]).value.fields
  values.zip(counts).to_h
end

#variance(ddof: 0, skip_nulls: true, min_count: 1) ⇒ Float

Note:

Self must be a numeric Vector.

Calculate variance of self.

Unary aggregation function

Returns a scalar.

Parameters:

  • ddof (0, 1) (defaults to: 0) —

    Control Delta Degrees of Freedom (ddof) of Variance and Stddev kernel. The divisor used in calculations is N - ddof, where N is the number of elements. By default, ddof is zero, and population variance or stddev is returned.

  • skip_nulls (true, false) (defaults to: true) —

    If true, nil values are ignored. Otherwise, if any value is nil, emit nil.

  • min_count (Integer) (defaults to: 1) —

    if less than this many non-nil values are observed, emit nil. If skip_nulls is false, this option is not respected.

Returns:

  • (Float) —

    unviased (ddof=1) standard deviation of self by default.

  • (Float) —

    variance of self. Biased (ddof=0) by default.



235
 
# File 'lib/red_amber/vector_aggregation.rb', line 235

define_unary_aggregation :variance

#xor(other) ⇒ Vector Also known as: ^

Logical ‘xor’ boolean values

When a nil is encountered in either input, a nil is output.

Binary element-wise function

Returns a Vector.

Parameters:

  • other (Vector) —

    other boolean vector or boolean scalar.

Returns:

  • (Vector) —

    eq of self and other by a boolean Vector.



452
 
# File 'lib/red_amber/vector_binary_element_wise.rb', line 452

define_binary_element_wise :xor