/usr/include/boost/accumulators/statistics
Edit: /usr/include/boost/accumulators/statistics/rolling_window.hpp (7254B)
///////////////////////////////////////////////////////////////////////////////
// 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
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost { namespace serialization {
// implement serialization for boost::circular_buffer
template
void save(Archive& ar, const circular_buffer& b, const unsigned int /* version */)
{
typename circular_buffer::size_type size = b.size();
ar << b.capacity();
ar << size;
const typename circular_buffer::const_array_range one = b.array_one();
const typename circular_buffer::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
void load(Archive& ar, circular_buffer& b, const unsigned int /* version */)
{
typename circular_buffer::capacity_type capacity;
typename circular_buffer::size_type size;
ar >> capacity;
b.set_capacity(capacity);
ar >> size;
b.clear();
const typename circular_buffer::pointer buff = new T[size*sizeof(T)];
ar.load_binary(buff, size*sizeof(T));
b.insert(b.begin(), buff, buff+size);
delete[] buff;
}
template
inline void serialize(Archive & ar, circular_buffer& 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
struct rolling_window_plus1_impl
: accumulator_base
{
typedef typename circular_buffer::const_iterator const_iterator;
typedef iterator_range result_type;
template
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
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
void serialize(Archive & ar, const unsigned int version)
{
ar & buffer_;
}
private:
circular_buffer buffer_;
};
template
bool is_rolling_window_plus1_full(Args const &args)
{
return find_accumulator(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
struct rolling_window_impl
: accumulator_base
{
typedef typename circular_buffer::const_iterator const_iterator;
typedef iterator_range result_type;
rolling_window_impl(dont_care)
{}
template
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
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 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 const window_size;
#endif
};
} // namespace tag
///////////////////////////////////////////////////////////////////////////////
// extract::rolling_window_plus1
// extract::rolling_window
//
namespace extract
{
extractor const rolling_window_plus1 = {};
extractor 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