///////////////////////////////////////////////////////////////////////////////
|
// rolling_window.hpp
|
//
|
// Copyright 2008 Eric Niebler. Distributed under the Boost
|
// Software License, Version 1.0. (See accompanying file
|
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
#ifndef BOOST_ACCUMULATORS_STATISTICS_ROLLING_WINDOW_HPP_EAN_26_12_2008
|
#define BOOST_ACCUMULATORS_STATISTICS_ROLLING_WINDOW_HPP_EAN_26_12_2008
|
|
#include <cstddef>
|
#include <boost/version.hpp>
|
#include <boost/assert.hpp>
|
#include <boost/circular_buffer.hpp>
|
#include <boost/range/iterator_range.hpp>
|
#include <boost/accumulators/accumulators_fwd.hpp>
|
#include <boost/accumulators/framework/extractor.hpp>
|
#include <boost/accumulators/framework/depends_on.hpp>
|
#include <boost/accumulators/framework/accumulator_base.hpp>
|
#include <boost/accumulators/framework/parameters/sample.hpp>
|
#include <boost/accumulators/framework/parameters/accumulator.hpp>
|
#include <boost/accumulators/numeric/functional.hpp>
|
#include <boost/accumulators/statistics_fwd.hpp>
|
#include <boost/serialization/split_free.hpp>
|
|
namespace boost { namespace serialization {
|
|
// implement serialization for boost::circular_buffer
|
template <class Archive, class T>
|
void save(Archive& ar, const circular_buffer<T>& b, const unsigned int /* version */)
|
{
|
typename circular_buffer<T>::size_type size = b.size();
|
ar << b.capacity();
|
ar << size;
|
const typename circular_buffer<T>::const_array_range one = b.array_one();
|
const typename circular_buffer<T>::const_array_range two = b.array_two();
|
ar.save_binary(one.first, one.second*sizeof(T));
|
ar.save_binary(two.first, two.second*sizeof(T));
|
}
|
|
template <class Archive, class T>
|
void load(Archive& ar, circular_buffer<T>& b, const unsigned int /* version */)
|
{
|
typename circular_buffer<T>::capacity_type capacity;
|
typename circular_buffer<T>::size_type size;
|
ar >> capacity;
|
b.set_capacity(capacity);
|
ar >> size;
|
b.clear();
|
const typename circular_buffer<T>::pointer buff = new T[size*sizeof(T)];
|
ar.load_binary(buff, size*sizeof(T));
|
b.insert(b.begin(), buff, buff+size);
|
delete[] buff;
|
}
|
|
template<class Archive, class T>
|
inline void serialize(Archive & ar, circular_buffer<T>& b, const unsigned int version)
|
{
|
split_free(ar, b, version);
|
}
|
|
} } // end namespace boost::serialization
|
|
namespace boost { namespace accumulators
|
{
|
|
///////////////////////////////////////////////////////////////////////////////
|
// tag::rolling_window::size named parameter
|
BOOST_PARAMETER_NESTED_KEYWORD(tag, rolling_window_size, window_size)
|
|
BOOST_ACCUMULATORS_IGNORE_GLOBAL(rolling_window_size)
|
|
namespace impl
|
{
|
///////////////////////////////////////////////////////////////////////////////
|
// rolling_window_plus1_impl
|
// stores the latest N+1 samples, where N is specified at construction time
|
// with the rolling_window_size named parameter
|
template<typename Sample>
|
struct rolling_window_plus1_impl
|
: accumulator_base
|
{
|
typedef typename circular_buffer<Sample>::const_iterator const_iterator;
|
typedef iterator_range<const_iterator> result_type;
|
|
template<typename Args>
|
rolling_window_plus1_impl(Args const & args)
|
: buffer_(args[rolling_window_size] + 1)
|
{}
|
|
#if BOOST_VERSION < 103600
|
// Before Boost 1.36, copying a circular buffer didn't copy
|
// it's capacity, and we need that behavior.
|
rolling_window_plus1_impl(rolling_window_plus1_impl const &that)
|
: buffer_(that.buffer_)
|
{
|
this->buffer_.set_capacity(that.buffer_.capacity());
|
}
|
|
rolling_window_plus1_impl &operator =(rolling_window_plus1_impl const &that)
|
{
|
this->buffer_ = that.buffer_;
|
this->buffer_.set_capacity(that.buffer_.capacity());
|
}
|
#endif
|
|
template<typename Args>
|
void operator ()(Args const &args)
|
{
|
this->buffer_.push_back(args[sample]);
|
}
|
|
bool full() const
|
{
|
return this->buffer_.full();
|
}
|
|
// The result of a shifted rolling window is the range including
|
// everything except the most recently added element.
|
result_type result(dont_care) const
|
{
|
return result_type(this->buffer_.begin(), this->buffer_.end());
|
}
|
|
template<class Archive>
|
void serialize(Archive & ar, const unsigned int version)
|
{
|
ar & buffer_;
|
}
|
|
private:
|
circular_buffer<Sample> buffer_;
|
};
|
|
template<typename Args>
|
bool is_rolling_window_plus1_full(Args const &args)
|
{
|
return find_accumulator<tag::rolling_window_plus1>(args[accumulator]).full();
|
}
|
|
///////////////////////////////////////////////////////////////////////////////
|
// rolling_window_impl
|
// stores the latest N samples, where N is specified at construction type
|
// with the rolling_window_size named parameter
|
template<typename Sample>
|
struct rolling_window_impl
|
: accumulator_base
|
{
|
typedef typename circular_buffer<Sample>::const_iterator const_iterator;
|
typedef iterator_range<const_iterator> result_type;
|
|
rolling_window_impl(dont_care)
|
{}
|
|
template<typename Args>
|
result_type result(Args const &args) const
|
{
|
return rolling_window_plus1(args).advance_begin(is_rolling_window_plus1_full(args));
|
}
|
|
// serialization is done by accumulators it depends on
|
template<class Archive>
|
void serialize(Archive & ar, const unsigned int file_version) {}
|
};
|
|
} // namespace impl
|
|
///////////////////////////////////////////////////////////////////////////////
|
// tag::rolling_window_plus1
|
// tag::rolling_window
|
//
|
namespace tag
|
{
|
struct rolling_window_plus1
|
: depends_on<>
|
, tag::rolling_window_size
|
{
|
/// INTERNAL ONLY
|
///
|
typedef accumulators::impl::rolling_window_plus1_impl< mpl::_1 > impl;
|
|
#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
|
/// tag::rolling_window::size named parameter
|
static boost::parameter::keyword<tag::rolling_window_size> const window_size;
|
#endif
|
};
|
|
struct rolling_window
|
: depends_on< rolling_window_plus1 >
|
{
|
/// INTERNAL ONLY
|
///
|
typedef accumulators::impl::rolling_window_impl< mpl::_1 > impl;
|
|
#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
|
/// tag::rolling_window::size named parameter
|
static boost::parameter::keyword<tag::rolling_window_size> const window_size;
|
#endif
|
};
|
|
} // namespace tag
|
|
///////////////////////////////////////////////////////////////////////////////
|
// extract::rolling_window_plus1
|
// extract::rolling_window
|
//
|
namespace extract
|
{
|
extractor<tag::rolling_window_plus1> const rolling_window_plus1 = {};
|
extractor<tag::rolling_window> const rolling_window = {};
|
|
BOOST_ACCUMULATORS_IGNORE_GLOBAL(rolling_window_plus1)
|
BOOST_ACCUMULATORS_IGNORE_GLOBAL(rolling_window)
|
}
|
|
using extract::rolling_window_plus1;
|
using extract::rolling_window;
|
|
}} // namespace boost::accumulators
|
|
#endif
|
