Module: ArrayExtension

Included in:
Array
Defined in:
lib/oha_extensions/array_extension.rb

Overview

This class adds the stats methods to array which computes sum, min, max, med, mean, count, std deviation

Instance Method Summary collapse

Instance Method Details

#average ⇒ Object

returns

The average value of the elements in the array



33
34
35
 
# File 'lib/oha_extensions/array_extension.rb', line 33

def average
  return stats[:sum] / size.to_f
end

#delete_first(element) ⇒ Object 



107
108
109
110
 
# File 'lib/oha_extensions/array_extension.rb', line 107

def delete_first(element)
  index = self.index(element)
  self.delete_at(index) if index
end

#next ⇒ Object 



98
99
100
101
 
# File 'lib/oha_extensions/array_extension.rb', line 98

def next
  @next_index = @next_index.nil? ? 0 : (@next_index + 1) % self.size
  return self[@next_index]
end

#process_in_batches(batch_size) ⇒ Object

Divides the calling array into batch_size batches, (the last batch could be less than batch_size if the calling array.size % batch_size != 0) and yields each batch

batch_size

The number elements to yield to the given block

Example: (1..30).to_a.process_in_batches(10) do |batch| p batch end

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [11, 12, 13, 14, 15, 16, 17, 18, 19, 20] [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]

Raises:

  • (ArgumentError) 


47
48
49
50
51
52
53
54
55
56
 
# File 'lib/oha_extensions/array_extension.rb', line 47

def process_in_batches(batch_size)
  raise ArgumentError if batch_size.nil? or batch_size <= 0
  
  index = 0
  
  while index < self.size
    yield self[index...index+batch_size]
    index += batch_size
  end
end

#rand ⇒ Object 



94
95
96
 
# File 'lib/oha_extensions/array_extension.rb', line 94

def rand
  self[Kernel.rand(self.length)]
end

#shuffle ⇒ Object 



103
104
105
 
# File 'lib/oha_extensions/array_extension.rb', line 103

def shuffle
  self.sort_by{ Kernel.rand }
end

#stats ⇒ Object

Given an array of values it returns the mean, median, min, max in a hash

array

An array whose values are used to calculate the various statistics

returns

A hash with the following keys

  • sum
  • mean
  • min
  • max
  • median
  • count (number of items in the array) All keys will => 0, if the array is empty The array is automatically sorted when you call stats


14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/oha_extensions/array_extension.rb', line 14

def stats
  return {:sum => 0, :mean => 0, :min => 0, :max => 0, :median => 0, :std_dev => 0, :count => 0} if empty?
  out = Hash.new
  sort!
  out[:sum] = inject(0){|sum, element| sum + element}
  out[:mean] = out[:sum]/size.to_f
  out[:min] = min
  out[:max] = max
  out[:median] = size % 2 == 0 ? (self[size/2] + self[size/2 - 1]) / 2.0 : self[size/2]
  out[:count] = size
  if size > 1
    out[:std_dev] = Math.sqrt((inject(0){|sum_square, element| sum_square += element * element} - out[:sum]*out[:mean]) / (size - 1)) 
  else
    out[:std_dev] = 0
  end
  return out
end

#to_hash_with_keys(options = {}, &block) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/oha_extensions/array_extension.rb', line 58

def to_hash_with_keys(options={}, &block)
  options = {:value_acts_as_array => false}.merge(options)
  return self.inject(Hash.new) do |injection, var| 
    key = block.call(var)
    if options[:value_acts_as_array]
      if injection[key].nil?
        injection[key] = [var]
      else
        injection[key] << var
      end
    else
      injection[key] = var
    end
    
    injection
  end
end

#to_identity_hash(id_proc = nil) ⇒ Object

useful for creating in memory mappings of ActiveRecord models



85
86
87
88
89
90
91
92
 
# File 'lib/oha_extensions/array_extension.rb', line 85

def to_identity_hash(id_proc = nil)
  h = Hash.new
  self.each do |e|
    key = id_proc ? id_proc.call(e) : (block_given? ? yield(e) : e.id)
    h[key] = e
  end
  return h
end

#to_lookup_hash ⇒ Object 



76
77
78
79
80
81
82
 
# File 'lib/oha_extensions/array_extension.rb', line 76

def to_lookup_hash()
  h = Hash.new
  self.each do |e|
    h[e] = block_given? ? yield(e) : true
  end
  return h
end