Class: RedAmber::Group

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/red_amber/group.rb

Overview

group class

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(dataframe, *group_keys) ⇒ Group

Creates a new Group object.

Parameters:

  • dataframe (DataFrame) —

    dataframe to be grouped.

  • group_keys (Array<>) —

    keys for grouping.

Raises:



14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/red_amber/group.rb', line 14

def initialize(dataframe, *group_keys)
  @dataframe = dataframe
  @group_keys = group_keys.flatten

  raise GroupArgumentError, 'group_keys are empty.' if @group_keys.empty?

  d = @group_keys - @dataframe.keys
  raise GroupArgumentError, "#{d} is not a key of\n #{@dataframe}." unless d.empty?

  @group = @dataframe.table.group(*@group_keys)
end

Instance Attribute Details

#dataframe ⇒ Object (readonly)

Returns the value of attribute dataframe.



26
27
28
 
# File 'lib/red_amber/group.rb', line 26

def dataframe
  @dataframe
end

#group_keys ⇒ Object (readonly)

Returns the value of attribute group_keys.



26
27
28
 
# File 'lib/red_amber/group.rb', line 26

def group_keys
  @group_keys
end

Instance Method Details

#agg_sum(*summary_keys) ⇒ Object

experimental



103
104
105
 
# File 'lib/red_amber/group.rb', line 103

def agg_sum(*summary_keys)
  call_aggregating_function(:sum, summary_keys, _options = nil)
end

#count(*summary_keys) ⇒ Object 



47
48
49
50
51
52
53
54
55
 
# File 'lib/red_amber/group.rb', line 47

def count(*summary_keys)
  df = __count(summary_keys)
  # if counts are the same (and do not include NaN or nil), aggregate count columns.
  if df.pick(@group_keys.size..).to_h.values.uniq.size == 1
    df.pick(0..@group_keys.size).rename { [keys[-1], :count] }
  else
    df
  end
end

#each ⇒ Object 



72
73
74
75
76
77
78
79
80
 
# File 'lib/red_amber/group.rb', line 72

def each
  filters
  return enum_for(:each) unless block_given?

  @filters.each do |filter|
    yield @dataframe[filter]
  end
  @filters.size
end

#filters ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/red_amber/group.rb', line 57

def filters
  @filters ||= begin
    first, *others = @group_keys.map do |key|
      vector = @dataframe[key]
      vector.uniq.each.map { |u| u.nil? ? vector.is_nil : vector == u }
    end

    if others.empty?
      first.select(&:any?)
    else
      first.product(*others).map { |a| a.reduce(&:&) }.select(&:any?)
    end
  end
end

#group_count ⇒ Object 



82
83
84
 
# File 'lib/red_amber/group.rb', line 82

def group_count
  DataFrame.create(add_columns_to_table(base_table, [:group_count], [group_counts]))
end

#inspect ⇒ Object 



86
87
88
 
# File 'lib/red_amber/group.rb', line 86

def inspect
  "#<#{self.class} : #{format('0x%016x', object_id)}>\n#{group_count}"
end

#summarize(&block) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/red_amber/group.rb', line 90

def summarize(&block)
  agg = instance_eval(&block)
  case agg
  when DataFrame
    agg
  when Array
    agg.reduce { |aggregated, df| aggregated.assign(df.to_h) }
  else
    raise GroupArgumentError, "Unknown argument: #{agg}"
  end
end