Berechne Rolling / Moving Average in C ++

Wenn sich Ihre Bedürfnisse sind einfach, Sie könnten nur versuchen, mit einem exponentiellen gleitenden Durchschnitt.

http://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average

Einfach gesagt, Sie machen eine Akkumulator-variable, und wie dein code aussieht, bei jeder Probe, die code-updates der Akku mit dem neuen Wert. Wählen Sie eine Konstante "alpha", der zwischen 0 und 1, und berechnen Sie diese:

accumulator = (alpha * new_value) + (1.0 - alpha) * accumulator

Brauchen Sie nur zu finden, die einen Wert von "alpha", bei denen die Wirkung einer bestimmten Probe dauert nur etwa 1000 Proben.

Hmm, ich bin eigentlich nicht sicher, dass dies für Sie geeignet ist, nun habe ich ihn hier. Das problem ist, dass 1000 ist eine ziemlich lange Fenster für einen exponentiellen gleitenden Durchschnitt; ich bin nicht sicher, es ist eine alpha, die verbreitet sich der Durchschnitt über die letzten 1000 zahlen, ohne Unterlauf in der floating-point-Berechnung. Aber wenn Sie wollten eine kleinere Durchschnittliche, wie 30 zahlen oder so, ist dies eine sehr einfache und schnelle Art und Weise, es zu tun.

InformationsquelleAutor der Antwort steveha

Grundsätzlich möchte ich Spur den gleitenden Durchschnitt der ein kontinuierlicher Strom von einem Strom von floating-point-zahlen über die letzten 1000 zahlen-Daten-Beispiel.

Beachten Sie, dass die folgenden updates der total_ als Elemente Hinzugefügt/ersetzt, Vermeidung von Kosten O(N) traversal, die zur Berechnung benötigte für die durchschnittlichen - auf Nachfrage.

template <typename T, typename Total, int N>
class Moving_Average
{
  public:
    Moving_Average()
      : num_samples_(0), total_(0)
    { }

    void operator()(T sample)
    {
        if (num_samples_ < N)
        {
            samples_[num_samples_++] = sample;
            total_ += sample;
        }
        else
        {
            T& oldest = samples_[num_samples_++ % N];
            total_ += sample - oldest;
            oldest = sample;
        }
    }

    operator double() const { return total_ / std::min(num_samples_, N); }

  private:
    T samples_[N];
    int num_samples_;
    Total total_;
};

Total ist aus einem anderen parameter aus T zu unterstützen, z.B. mit einem long long wenn insgesamt 1000 longs, ein int für chars, oder ein double zu insgesamt floats.

Dies ist ein wenig fehlerhaft, dass num_samples_ gehen könnte Vergangenheit INT_MAX - wenn Sie kümmern Sie könnten eine unsigned long long, oder verwenden Sie eine zusätzliche bool-Daten Mitglied aufnehmen, wenn der container zum ersten mal gefüllt, während Radfahren num_samples_ rund um das array (am besten dann in etwas harmlosen wie "pos").

InformationsquelleAutor der Antwort Tony Delroy

Könnten Sie implementieren eine Ringpuffer. Machen Sie ein array mit 1000 Elementen, und einige Felder zum speichern der start-und end-Indizes und Gesamtgröße. Dann speichern nur die letzten 1000 Elemente im Ringpuffer, und berechnen den durchschnittlichen Bedarf.

InformationsquelleAutor der Antwort Tim

Ein Weg sein kann, um Zirkular speichern der Werte in dem Puffer-array. und berechnen Sie die Durchschnittliche auf diese Weise.

int j = (int) (counter % size);
buffer[j] = mostrecentvalue;
avg = (avg * size - buffer[j - 1 == -1 ? size - 1 : j - 1] + buffer[j]) / size;

counter++;

//buffer[j - 1 == -1 ? size - 1 : j - 1] is the oldest value stored

Das ganze läuft in einer Schleife, wo die meisten aktuellen Wert dynamisch ist.

InformationsquelleAutor der Antwort Nilesh Kumar Jha