boost的accumulator rolling_mean的使用

Boost.Accumulators is both a library for incremental statistical computation as well as an extensible framework for incremental calculation in general. The library deals primarily with the concept of an accumulator, which is a primitive computational entity that accepts data one sample at a time and maintains some internal state. These accumulators may offload some of their computations on other accumulators, on which they depend. Accumulators are grouped within an accumulator set. Boost.Accumulators resolves the inter-dependencies between accumulators in a set and ensures that accumulators are processed in the proper order.

The rolling mean is the mean over the last N samples. It is computed by dividing the rolling sum by the rolling count.

Lazy or iterative calculation of the mean over the last N samples. The lazy calculation is associated with the tag::lazy_rolling_mean feature, and the iterative calculation (which is the default) with the tag::immediate_rolling_mean feature. Both can be extracted using the tag::rolling_mean() extractor.
 
把連續取得的N個採樣值當作一個隊列，隊列的長度固定爲N，
每次採樣到一個新數據放入隊尾，並扔掉原來隊首的一次數據（先進先出原則），
把隊列中的N個數據進行算術平均運算，得到新的濾波結果。

#include <iostream>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/rolling_mean.hpp>

using namespace boost::accumulators;

int main()
{
        accumulator_set<int, stats<tag::rolling_mean> > acc(tag::rolling_window::window_size = 7);

    // push in some data ...
        acc(1);
        acc(2);
        acc(3);
        std::cout << "Mean: " << rolling_mean(acc) << std::endl;

        acc(4);
        acc(5);
        acc(6);
        acc(7);
        std::cout << "Mean: " << rolling_mean(acc) << std::endl;

    return 0;
}
輸出
Mean: 2
Mean: 4

 

#include <iostream>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/moment.hpp>

using namespace boost::accumulators;

int main()
{
    // Define an accumulator set for calculating the mean and the
    // 2nd moment ...
    accumulator_set<double, stats<tag::mean, tag::moment<2> > > acc;

    // push in some data ...
    acc(1.2);
    acc(2.3);
    acc(3.4);
    acc(4.5);

    // Display the results ...
    std::cout << "Mean: " << mean(acc) << std::endl;
    std::cout << "Moment: " << moment<2>(acc) << std::endl;

    return 0;
}

結果

Mean: 2.85
Moment: 9.635


----------------------

 Usage of the framework follows the following pattern:

  1. Users build a computational object, called an accumulator_set<>, by selecting the
       computations in which they are interested, or authoring their own computational
       primitives which fit within the framework.

   2. Users push data into the accumulator_set<> object one sample at a time.
    
   3. The accumulator_set<> computes the requested quantities in the most efficient method
        possible, resolving dependencies between requested calculations, possibly caching
        intermediate results.

The Accumulators Framework defines the utilities needed for defining primitive computational elements, called accumulators. It also provides the accumulator_set<> type, described above.

// In header: <boost/accumulators/framework/accumulator_set.hpp>

template<typename Sample, typename Features, typename Weight>
struct accumulator_set {
  // types
  typedef Sample sample_type; // The type of the samples that will be accumulated.
  typedef Features features_type; // An MPL sequence of the features that should be accumulated.
  typedef Weight weight_type; // The type of the weight parameter. Must be a scalar. Defaults to void.
  typedef void result_type;

  // member classes/structs/unions
  template<typename Feature>
  struct apply {
  };

可見 accumulator_set 是個類模板。模板的第一個參數表示樣本的類型，
use the features<> template to specify a list of features to be calculated


template <class T>
class stats
{
public:
   stats()
      : m_min(tools::max_value<T>()),
        m_max(-tools::max_value<T>()),
        m_total(0),
        m_squared_total(0),
        m_count(0)
   {}
...

stats 也是一個類模版，T = Tag::mean 是參數類型。

namespace tag
{
    struct mean
      : depends_on<count, sum>
    {
        /// INTERNAL ONLY
        ///
        typedef accumulators::impl::mean_impl<mpl::_1, sum> impl;
    };

    struct immediate_mean
      : depends_on<count>
    {
        /// INTERNAL ONLY
        ///
        typedef accumulators::impl::immediate_mean_impl<mpl::_1, tag::sample> impl;
    };

因而可知 tag 是一種命名空間 mean 是一個結構體

-------------------------關於 tag::moment< para > --------------------

 Header

#include <boost/accumulators/statistics/moment.hpp>

Example

accumulator_set<int, stats<tag::moment<2> > > acc1;

acc1(2); // 4
acc1(4); // 16
acc1(5); // + 25
         // = 45 / 3 = 15

BOOST_CHECK_CLOSE(15., accumulators::moment<2>(acc1), 1e-5);

-----------------------------------------------------------------
accumulator_set<int, stats<tag::moment<5> > > acc2;

acc2(2); // 32
acc2(3); // 243
acc2(4); // 1024
acc2(5); // + 3125
         // = 4424 / 4 = 1106

BOOST_CHECK_CLOSE(1106., accumulators::moment<5>(acc2), 1e-5);

可見 tag::moment< para > 是一個結構體 就是一個類模板， 模板的參數para指定了矩的類型，
para = 2 是二次矩，也就是方差。