Ruby：使用数组和循环 - 简单的移动平均线

Question

working with simple moving averages in ruby, and came up with this code, specifically a three-day moving average:

 a = [3, 3, 3, 3, 5, 9, 7, 8, 9, 11]
 sma = []

 for i in 2 ... 9 do
   sma.push((a[i] + a[i-1] + a[i-2])/3.0)
 end

This code passes and it seems simple enough, however, what if the array contains over hundreds of items? How would I add 50 items for a 50-day average? Is there a different approach or should another loop be nested into the code?

*Also, I understand there are gems out there for this type of operation, but I'm more interested in creating this from scratch.

Answer 1

The method Enumerable#each_cons is perfect for this calculation:

def moving_average(a, ndays, precision)
  a.each_cons(ndays).map { |e| e.reduce(&:+).fdiv(ndays).round(precision) }
end

a = [3, 4, 1, 2, 5, 9, 7, 8, 9, 11]

moving_average(a,3,2)
  #=> [2.67, 2.33, 2.67, 5.33, 7.0, 8.0, 8.0, 9.33] 

For this example,

enum = a.each_cons(3) 
  #=> #<Enumerator: [3, 4, 1, 2, 5, 9, 7, 8, 9, 11]:each_cons(3)> 

The values the enumerator enum passes into the block can be obtained by converting enum to an array:

enum.to_a 
  #=> [[3, 4, 1], [4, 1, 2], [1, 2, 5], [2, 5, 9],
  #    [5, 9, 7], [9, 7, 8], [7, 8, 9], [8, 9, 11]]

map then converts each of these elements to an average.

---

If a and ndays are large, greater efficiency can be achieved as follows.

def moving_average(a,ndays,precision)
  (0..a.size-ndays-1).each_with_object([a[0,ndays].sum]) do |i,arr|
    arr << arr.last - a[i] + a[i+ndays]
  end.map { |tot| tot.fdiv(ndays).round(precision) }
end

moving_average(a,3,2)
  #=> [2.67, 2.33, 2.67, 5.33, 7.0, 8.0, 8.0, 9.33] 

After totaling

tot1 = [3, 4, 1].sum
  #=> 8

which is needed to compute the first 3-day moving average, the total of [4, 1, 2] , needed to compute the second 3-day moving average, is calculated as follows:

tot2 = tot1 + 2 - 3
  #=> 7

where 2 is the last element of [4, 1, 2] and 3 is the first element of [3, 4, 1] .

While there was no time savings for this example it can be seen that computing each total from the previous one would save time when a and ndays are large, as the computational complexity is reduced from O(n^2) to O(n) , where n = a.size .