Алгоритм скользящего среднего/суммы

Я бы сказал, используйте очередь, нажмите новую и вытащите старую. Для отслеживания среднего значения вы также можете просто вычесть полученное значение из промежуточной суммы и добавить новое (вам понадобится статическая переменная или переменная экземпляра или передача старой суммы). Нет необходимости обращаться к остальным элементам. Кроме того, где инициализируется runningTotal, если не тогда, когда initFlag имеет значение true?

private double rollingTotal(double d, boolean initFlag) {
    if(initFlag) vals = new Queue<Integer>();
    else {
        if(vals.size() == 7) // replace 7 with i.
            total -= vals.pop().intValue();
        }
        vals.push(d);
        total += d;
    }
    return total;
}

Я считаю, что очередь абстрактна, поэтому вам нужно выяснить, какую реализацию использовать. Я предлагаю вариант на основе связанного списка.

Это, безусловно, работает, но вы делаете немного больше работы, чем нужно. Вы можете избежать перемещения всех этих данных, и вы можете настроить их так, чтобы вычисление следующего итога было вопросом вычитания самого старого значения и добавления нового значения.

Например:

// assume that currentIndex is where you want to add the new item
// You have another value, currentTotal, that is initialized at 0.
currentTotal = currentTotal - runningTotal[currentIndex] + d;
runningTotal[currentIndex] = d;
// increment the index.
currentIndex = (currentIndex + 1) % 7;

При этом используется циклический буфер и сохраняется currentTotal, чтобы он всегда был доступен.

Вы можете попробовать использовать круговой буфер вместо перемещения всех данных при каждом добавлении:

runningTotal[nextIndex] = d;
nextIndex+=1;
if (nextIndex>=7) nextIndex = 0;

Таким образом, nextIndex всегда указывает на самое старое данное. Вы по-прежнему можете суммировать от начала до конца, как и раньше.

Вы можете использовать экспоненциально-взвешенное скользящее среднее. Его довольно долго писать, но код тривиален по сравнению с ним. Это, как правило, дает более гладкие результаты.

double previous;
static final double DAY = 1.0;
static final double WEEK = 6.0;
static final double ALPHA = DAY/WEEK;

private double movingAverage(double d) {
    return previous = ALPHA * d + (1 - ALPHA) * previous ;
}

Примечание: это оптимизированная версия формулы

double previous;
static final double DAY = 1.0;
static final double WEEK = 6.0;
static final double ALPHA = 1 - Math.exp(-DAY/WEEK);

private double movingAverage(double d) {
    return previous = ALPHA * d + (1 - ALPHA) * previous ;
}

В этом случае более поздняя формула является более точной, и, поскольку альфа не меняет, накладные расходы Math.exp не важны. Если альфа может меняться и обычно мала, я предлагаю использовать первую формулу.

Было бы проще использовать ArrayList вместо массива. Тогда вы могли бы просто использовать

ArrayList<Double> runningTotal = new ArrayList<Double>();

....

runningTotal.remove(0);
runningTotal.add(d);

Почему вы инициализируете runningTotal нулем? Каков его тип? Где это заявлено? Было бы хорошо, если бы вы разместили несколько примеров кода, которые напоминают реальный код Java.

Двигаясь дальше, моя критика будет следующей: ваша функция делает слишком много. Функция или метод должны быть связными. Точнее, они должны делать одно и только одно.

Что еще хуже, что происходит в вашем цикле for, когда x = 5? Вы копируете runningTotal[6] в runningTotal[5], но тогда у вас есть две копии одного и того же значения в позиции 5 и 6.

В вашем дизайне ваша функция

1. перемещает/перетасовывает элементы в вашем массиве
2. вычисляет общую
3. печатает материал со стандартной ошибкой
4. возвращает общее количество

Это слишком много.

Мое первое предложение - не перемещать вещи в массиве. Вместо этого реализуйте циклический буфер и используйте его вместо массива. Это упростит ваш дизайн. Мое второе предложение состоит в том, чтобы разбить вещи на связанные функции:

1. иметь структуру данных (круговой буфер), которая позволяет вам добавлять к ней (и которая удаляет самую старую запись всякий раз, когда она достигает своей емкости).
2. иметь структуру данных, реализующую интератор
3. есть функция, которая вычисляет итог на итераторе (вам все равно, вычисляете ли вы итог из массива, списка или циклического буфера.)
4. не называйте это тотальным. Назовите это суммой, которую вы вычисляете.

Я бы так и сделал :)

// java pseudocode below - might not compile.

// assume you have a class called CircularBuffer, of say, doubles,
public class CircularBuffer
{
  public CircularBuffer(final int capacity) {...}
  public int getSize(){ ... return # of elements in it ... }
  public add(final Double d){ ... add to the end, drop from the front if we reach capacity... }
  public Iterator<Double> iterator(){ ... gets an interator over the content of the buffer ...}
}

// somewhere else, in another class... NOT ON CircularBuffer

public class Calculator
{
  //assume none of the double values is null
  static public Double sum(final Double ... doubles )
  {
    double sum= 0;
    for( Double d : doubles )
    {
      total += d.doubleValue();
    }
    return sum;
  }

 // you can calculate other things too
 static public Double avg(final Double ... doubles ){...}
 static public Double std(final Double ... doubles ){...}
}

/// somewhere else
{
  CircularBuffer buffer = new CircularBuffer(7);

  while( readingAndReadingAndReading )
  {
    // drops oldest values as it reaches capacity
    // always keeping the latest 7 readings
    buffer.add( getLatestValueFromSomewhere() );
  }

  System.out.println( "total=" + Calculator.sum() );
  System.out.println( "average=" + Calculator.avg() );
  System.out.println( "standard deviation=" + Calculator.std() );
}

Ваша задача слишком проста, и выбранный вами подход, безусловно, хорош для этой работы. Однако, если вы хотите использовать лучший дизайн, вы должны избавиться от всего этого движения чисел; вам лучше использовать очередь FIFO и хорошо использовать методы push и pop; таким образом код не будет отражать какое-либо перемещение данных, а только два логических действия «новые данные» и «удалить данные старше 7 дней».