Method: Rust::DataFrame#aggregate

Defined in:

lib/rust/core/types/dataframe.rb

#aggregate(by, **aggregators) ⇒ Object

Raises:

• (TypeError)

# File 'lib/rust/core/types/dataframe.rb', line 379

def aggregate(by, **aggregators)
    raise TypeError, "Expected a string" unless by.is_a?(String)
    raise TypeError, "All the aggregators should be procs" unless aggregators.values.all? { |v| v.is_a?(Proc) }
    raise "Expected a block for default aggregator" unless block_given?
    
    aggregators = aggregators.map { |label, callable| [label.to_s, callable] }.to_h
    
    sorted = self.sort_by(by)
    
    current_value = nil
    partials = []
    partial = nil
    sorted.column(by).each_with_index do |value, index|
        if current_value != value
            current_value = value
            partials << partial if partial
            partial = Rust::DataFrame.new(self.column_names)
        end
        partial << sorted.fast_row(index)
    end
    partials << partial
    
    result = Rust::DataFrame.new(self.column_names)
    partials.each do |partial|
        aggregated_row = {}
        aggregated_row[by] = partial.column(by)[0]
        (self.column_names - [by]).each do |column|
            if aggregators[column]
                aggregated_row[column] = aggregators[column].call(partial.column(column))
            else
                aggregated_row[column] = yield partial.column(column)
            end
        end
        
        result << aggregated_row
    end
    
    return result
end