/////////////////////////////////////////////////////////////////////////////// | |
// 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 <boost/mpl/placeholders.hpp> | |
#include <boost/accumulators/framework/accumulator_base.hpp> | |
#include <boost/accumulators/framework/extractor.hpp> | |
#include <boost/accumulators/numeric/functional.hpp> | |
#include <boost/accumulators/framework/parameters/sample.hpp> | |
#include <boost/accumulators/framework/depends_on.hpp> | |
#include <boost/accumulators/statistics_fwd.hpp> | |
#include <boost/accumulators/statistics/count.hpp> | |
#include <boost/accumulators/statistics/variance.hpp> | |
#include <boost/accumulators/statistics/weighted_sum.hpp> | |
#include <boost/accumulators/statistics/weighted_mean.hpp> | |
#include <boost/accumulators/statistics/weighted_moment.hpp> | |
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<typename Sample, typename Weight, typename MeanFeature> | |
struct lazy_weighted_variance_impl | |
: accumulator_base | |
{ | |
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample; | |
// for boost::result_of | |
typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type; | |
lazy_weighted_variance_impl(dont_care) {} | |
template<typename Args> | |
result_type result(Args const &args) const | |
{ | |
extractor<MeanFeature> 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 smaples. Note that the sample variance is not defined for | |
\f$n <= 1\f$. | |
*/ | |
template<typename Sample, typename Weight, typename MeanFeature, typename Tag> | |
struct weighted_variance_impl | |
: accumulator_base | |
{ | |
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample; | |
// for boost::result_of | |
typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type; | |
template<typename Args> | |
weighted_variance_impl(Args const &args) | |
: weighted_variance(numeric::average(args[sample | Sample()], numeric::one<Weight>::value)) | |
{ | |
} | |
template<typename Args> | |
void operator ()(Args const &args) | |
{ | |
std::size_t cnt = count(args); | |
if(cnt > 1) | |
{ | |
extractor<MeanFeature> const some_mean = {}; | |
result_type tmp = args[parameter::keyword<Tag>::get()] - some_mean(args); | |
this->weighted_variance = | |
numeric::average(this->weighted_variance * (sum_of_weights(args) - args[weight]), sum_of_weights(args)) | |
+ numeric::average(tmp * tmp * args[weight], sum_of_weights(args) - args[weight] ); | |
} | |
} | |
result_type result(dont_care) const | |
{ | |
return this->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_moment<2>, weighted_mean> | |
{ | |
/// INTERNAL ONLY | |
/// | |
typedef accumulators::impl::lazy_weighted_variance_impl<mpl::_1, mpl::_2, weighted_mean> impl; | |
}; | |
struct weighted_variance | |
: depends_on<count, immediate_weighted_mean> | |
{ | |
/// INTERNAL ONLY | |
/// | |
typedef accumulators::impl::weighted_variance_impl<mpl::_1, mpl::_2, immediate_weighted_mean, sample> impl; | |
}; | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
// extract::weighted_variance | |
// extract::immediate_weighted_variance | |
// | |
namespace extract | |
{ | |
extractor<tag::lazy_weighted_variance> const lazy_weighted_variance = {}; | |
extractor<tag::weighted_variance> 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<tag::weighted_variance(lazy)> | |
{ | |
typedef tag::lazy_weighted_variance type; | |
}; | |
// weighted_variance(immediate) -> weighted_variance | |
template<> | |
struct as_feature<tag::weighted_variance(immediate)> | |
{ | |
typedef tag::weighted_variance type; | |
}; | |
//////////////////////////////////////////////////////////////////////////// | |
//// droppable_accumulator<weighted_variance_impl> | |
//// need to specialize droppable lazy weighted_variance to cache the result at the | |
//// point the accumulator is dropped. | |
///// INTERNAL ONLY | |
///// | |
//template<typename Sample, typename Weight, typename MeanFeature> | |
//struct droppable_accumulator<impl::weighted_variance_impl<Sample, Weight, MeanFeature> > | |
// : droppable_accumulator_base< | |
// with_cached_result<impl::weighted_variance_impl<Sample, Weight, MeanFeature> > | |
// > | |
//{ | |
// template<typename Args> | |
// droppable_accumulator(Args const &args) | |
// : droppable_accumulator::base(args) | |
// { | |
// } | |
//}; | |
}} // namespace boost::accumulators | |
#endif |