Calculating averages of elements in a sequence without iterating over it - c++

Question

Write a class that takes in a step size (n) in its constructor. The only method in the class takes in an integer, adds it into a sequence of numbers, and returns the average of the last n values inserted into the sequence. Do not iterate over the sequence to calculate the average.
And NO, this isn't homework
Following is my way of doing it in C++:
Initialize two STL queue<int>, one of which has length n and is called buffer
User - input values are stored dynamically in the buffer. Once this buffer is full, add the user - input value to "sum" and subtract the buffer.front() value.
Push the first value from buffer into the second queue<int> named values
Pop the first value (buffer.pop())
return the average by dividing sum by n
Following is the code I came up with:
#ifndef calcAverage_Window_h
#define calcAverage_Window_h
#include <iostream>
#include <queue>
using namespace std;
class Window{
private:
int n, sum;
queue<int> values, buffer, sums;
public:
Window(int);
float calcAverage(int);
};
#endif
#include "Window.h"
Window::Window(int m){
n = m;
buffer.push(1);
buffer.push(2);
buffer.push(3);
sum = 6;
}
float Window::calcAverage(int val){
buffer.push(val);
values.push(buffer.front());
sum = sum + val - buffer.front();
buffer.pop();
return float(sum)/n; //float(sum) required so that calcAverage doesn't return an int
}
#include "Window.h"
int main()
{
Window w(3);
cout<<w.calcAverage(4)<<endl;
cout<<w.calcAverage(5)<<endl;
cout<<w.calcAverage(6)<<endl;
return 0;
}
I have the following questions:
Is there a better way to do this?
If we are not allowed to use STL either, I would implement a queue and use that for buffer and values. Does anyone have a better idea?
I cheated a bit by initializing the buffer in the Window(n) constructor. That is because: 1) I did not know how else I would go about it
2) It maybe clear for the case when n = 2, but it is ambiguous for n = 3.
Where will this method / code fail?
I came to think of this way empirically. Is there an algorithmic way to look at this problem?

Answer 1

To answer a few of your questions:
Where will this method / code fail?
Well, assuming the above code is bug-free, it will not necessarily work correctly if you decide to move to floating-point data.
Note that its overflow behaviour is also subtly different compared to a direct implementation of a moving average.
Is there an algorithmic way to look at this problem?
Yes. With window size L the moving sums for time n and time n-1 are as follows:
y[n] = x[n] + x[n-1] + ... + x[n-L+1]
y[n-1] = x[n-1] + ... + x[n-L+1] + x[n-L]
Subtract one equation from the other, you get:
y[n] - y[n-1] = x[n] - x[n-L]
Move y[n-1] to the other side of the equals sign, and you're done.