/usr/include/boost/accumulators/statistics
Edit: /usr/include/boost/accumulators/statistics/weighted_variance.hpp (6774B)
///////////////////////////////////////////////////////////////////////////////
// weighted_variance.hpp
//
// Copyright 2005 Daniel Egloff, 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_WEIGHTED_VARIANCE_HPP_EAN_28_10_2005
#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_VARIANCE_HPP_EAN_28_10_2005
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost { namespace accumulators
{
namespace impl
{
//! Lazy calculation of variance of weighted samples.
/*!
The default implementation of the variance of weighted samples is based on the second moment
\f$\widehat{m}_n^{(2)}\f$ (weighted_moment<2>) and the mean\f$ \hat{\mu}_n\f$ (weighted_mean):
\f[
\hat{\sigma}_n^2 = \widehat{m}_n^{(2)}-\hat{\mu}_n^2,
\f]
where \f$n\f$ is the number of samples.
*/
template
struct lazy_weighted_variance_impl
: accumulator_base
{
typedef typename numeric::functional::multiplies::result_type weighted_sample;
// for boost::result_of
typedef typename numeric::functional::fdiv::result_type result_type;
lazy_weighted_variance_impl(dont_care) {}
template
result_type result(Args const &args) const
{
extractor const some_mean = {};
result_type tmp = some_mean(args);
return accumulators::weighted_moment<2>(args) - tmp * tmp;
}
};
//! Iterative calculation of variance of weighted samples.
/*!
Iterative calculation of variance of weighted samples:
\f[
\hat{\sigma}_n^2 =
\frac{\bar{w}_n - w_n}{\bar{w}_n}\hat{\sigma}_{n - 1}^2
+ \frac{w_n}{\bar{w}_n - w_n}\left(X_n - \hat{\mu}_n\right)^2
,\quad n\ge2,\quad\hat{\sigma}_0^2 = 0.
\f]
where \f$\bar{w}_n\f$ is the sum of the \f$n\f$ weights \f$w_i\f$ and \f$\hat{\mu}_n\f$
the estimate of the mean of the weighted samples. Note that the sample variance is not defined for
\f$n <= 1\f$.
*/
template
struct weighted_variance_impl
: accumulator_base
{
typedef typename numeric::functional::multiplies::result_type weighted_sample;
// for boost::result_of
typedef typename numeric::functional::fdiv::result_type result_type;
template
weighted_variance_impl(Args const &args)
: weighted_variance(numeric::fdiv(args[sample | Sample()], numeric::one::value))
{
}
template
void operator ()(Args const &args)
{
std::size_t cnt = count(args);
if(cnt > 1)
{
extractor const some_mean = {};
result_type tmp = args[parameter::keyword::get()] - some_mean(args);
this->weighted_variance =
numeric::fdiv(this->weighted_variance * (sum_of_weights(args) - args[weight]), sum_of_weights(args))
+ numeric::fdiv(tmp * tmp * args[weight], sum_of_weights(args) - args[weight] );
}
}
result_type result(dont_care) const
{
return this->weighted_variance;
}
// make this accumulator serializeable
template
void serialize(Archive & ar, const unsigned int file_version)
{
ar & weighted_variance;
}
private:
result_type weighted_variance;
};
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
// tag::weighted_variance
// tag::immediate_weighted_variance
//
namespace tag
{
struct lazy_weighted_variance
: depends_on, weighted_mean>
{
/// INTERNAL ONLY
///
typedef accumulators::impl::lazy_weighted_variance_impl impl;
};
struct weighted_variance
: depends_on
{
/// INTERNAL ONLY
///
typedef accumulators::impl::weighted_variance_impl impl;
};
}
///////////////////////////////////////////////////////////////////////////////
// extract::weighted_variance
// extract::immediate_weighted_variance
//
namespace extract
{
extractor const lazy_weighted_variance = {};
extractor const weighted_variance = {};
BOOST_ACCUMULATORS_IGNORE_GLOBAL(lazy_weighted_variance)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_variance)
}
using extract::lazy_weighted_variance;
using extract::weighted_variance;
// weighted_variance(lazy) -> lazy_weighted_variance
template<>
struct as_feature
{
typedef tag::lazy_weighted_variance type;
};
// weighted_variance(immediate) -> weighted_variance
template<>
struct as_feature
{
typedef tag::weighted_variance type;
};
////////////////////////////////////////////////////////////////////////////
//// droppable_accumulator
//// need to specialize droppable lazy weighted_variance to cache the result at the
//// point the accumulator is dropped.
///// INTERNAL ONLY
/////
//template
//struct droppable_accumulator >
// : droppable_accumulator_base<
// with_cached_result >
// >
//{
// template
// droppable_accumulator(Args const &args)
// : droppable_accumulator::base(args)
// {
// }
//};
}} // namespace boost::accumulators
#endif