/usr/include/boost/accumulators/statistics
Edit: /usr/include/boost/accumulators/statistics/mean.hpp (9334B)
///////////////////////////////////////////////////////////////////////////////
// mean.hpp
//
// Copyright 2005 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_MEAN_HPP_EAN_28_10_2005
#define BOOST_ACCUMULATORS_STATISTICS_MEAN_HPP_EAN_28_10_2005
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost { namespace accumulators
{
namespace impl
{
///////////////////////////////////////////////////////////////////////////////
// mean_impl
// lazy, by default
template
struct mean_impl
: accumulator_base
{
// for boost::result_of
typedef typename numeric::functional::fdiv::result_type result_type;
mean_impl(dont_care) {}
template
result_type result(Args const &args) const
{
extractor sum;
return numeric::fdiv(sum(args), count(args));
}
// serialization is done by accumulators it depends on
template
void serialize(Archive & ar, const unsigned int file_version) {}
};
template
struct immediate_mean_impl
: accumulator_base
{
// for boost::result_of
typedef typename numeric::functional::fdiv::result_type result_type;
template
immediate_mean_impl(Args const &args)
: mean(numeric::fdiv(args[sample | Sample()], numeric::one::value))
{
}
template
void operator ()(Args const &args)
{
std::size_t cnt = count(args);
this->mean = numeric::fdiv(
(this->mean * (cnt - 1)) + args[parameter::keyword::get()]
, cnt
);
}
result_type result(dont_care) const
{
return this->mean;
}
template
void serialize(Archive & ar, const unsigned int file_version)
{
ar & mean;
}
private:
result_type mean;
};
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
// tag::mean
// tag::immediate_mean
// tag::mean_of_weights
// tag::immediate_mean_of_weights
// tag::mean_of_variates
// tag::immediate_mean_of_variates
//
namespace tag
{
struct mean
: depends_on
{
/// INTERNAL ONLY
///
typedef accumulators::impl::mean_impl impl;
};
struct immediate_mean
: depends_on
{
/// INTERNAL ONLY
///
typedef accumulators::impl::immediate_mean_impl impl;
};
struct mean_of_weights
: depends_on
{
typedef mpl::true_ is_weight_accumulator;
/// INTERNAL ONLY
///
typedef accumulators::impl::mean_impl impl;
};
struct immediate_mean_of_weights
: depends_on
{
typedef mpl::true_ is_weight_accumulator;
/// INTERNAL ONLY
///
typedef accumulators::impl::immediate_mean_impl impl;
};
template
struct mean_of_variates
: depends_on >
{
/// INTERNAL ONLY
///
typedef mpl::always > > impl;
};
template
struct immediate_mean_of_variates
: depends_on
{
/// INTERNAL ONLY
///
typedef mpl::always > impl;
};
}
///////////////////////////////////////////////////////////////////////////////
// extract::mean
// extract::mean_of_weights
// extract::mean_of_variates
//
namespace extract
{
extractor const mean = {};
extractor const mean_of_weights = {};
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, mean_of_variates, (typename)(typename))
BOOST_ACCUMULATORS_IGNORE_GLOBAL(mean)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(mean_of_weights)
}
using extract::mean;
using extract::mean_of_weights;
using extract::mean_of_variates;
// mean(lazy) -> mean
template<>
struct as_feature
{
typedef tag::mean type;
};
// mean(immediate) -> immediate_mean
template<>
struct as_feature
{
typedef tag::immediate_mean type;
};
// mean_of_weights(lazy) -> mean_of_weights
template<>
struct as_feature
{
typedef tag::mean_of_weights type;
};
// mean_of_weights(immediate) -> immediate_mean_of_weights
template<>
struct as_feature
{
typedef tag::immediate_mean_of_weights type;
};
// mean_of_variates(lazy) -> mean_of_variates
template
struct as_feature(lazy)>
{
typedef tag::mean_of_variates type;
};
// mean_of_variates(immediate) -> immediate_mean_of_variates
template
struct as_feature(immediate)>
{
typedef tag::immediate_mean_of_variates type;
};
// for the purposes of feature-based dependency resolution,
// immediate_mean provides the same feature as mean
template<>
struct feature_of
: feature_of
{
};
// for the purposes of feature-based dependency resolution,
// immediate_mean provides the same feature as mean
template<>
struct feature_of
: feature_of
{
};
// for the purposes of feature-based dependency resolution,
// immediate_mean provides the same feature as mean
template
struct feature_of >
: feature_of >
{
};
// So that mean can be automatically substituted with
// weighted_mean when the weight parameter is non-void.
template<>
struct as_weighted_feature
{
typedef tag::weighted_mean type;
};
template<>
struct feature_of
: feature_of
{};
// So that immediate_mean can be automatically substituted with
// immediate_weighted_mean when the weight parameter is non-void.
template<>
struct as_weighted_feature
{
typedef tag::immediate_weighted_mean type;
};
template<>
struct feature_of
: feature_of
{};
// So that mean_of_weights<> can be automatically substituted with
// weighted_mean_of_variates<> when the weight parameter is non-void.
template
struct as_weighted_feature >
{
typedef tag::weighted_mean_of_variates type;
};
template
struct feature_of >
: feature_of >
{
};
// So that immediate_mean_of_weights<> can be automatically substituted with
// immediate_weighted_mean_of_variates<> when the weight parameter is non-void.
template
struct as_weighted_feature >
{
typedef tag::immediate_weighted_mean_of_variates type;
};
template
struct feature_of >
: feature_of >
{
};
////////////////////////////////////////////////////////////////////////////
//// droppable_accumulator
//// need to specialize droppable lazy mean 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